diff -rN mpich2-1.0.7rc1/configure.in bgp-mpich2/configure.in 1022c1022 < eval dlldir=$libdir/libtvmpich2.so --- > eval dlldir=$libdir"64"/libbglmpi.so 1025c1025 < eval dlldir=$libdir/libtvmpich2.so --- > eval dlldir=$libdir"64"/libbglmpi.so 1100a1101,1103 > if test -n "$device_name" ; then > other_install_dirs="${other_install_dirs} src/mpid/$device_name" > fi 2217,2218c2220,2221 < GNU_VERSION=0 < GNU_MINORVERSION=0 --- > GNUC_VERSION=3 > GNUC_MINORVERSION=4 2219a2223 > if test "$cross_compiling" = "no"; then 2246a2251 > fi 4338c4343 < ],pac_cv_mpi_bsend_overhead=`cat conftestval`,pac_cv_mpi_bsend_overhead=128,pac_cv_mpi_bsend_overhead=128) --- > ],pac_cv_mpi_bsend_overhead=`cat conftestval`,pac_cv_mpi_bsend_overhead=62,pac_cv_mpi_bsend_overhead=62) 4764a4770,4773 > device) > MPID_TIMER_TYPE="double" > ;; > 5368c5377,5378 < if test -n "$MPI_OFFSET_TYPE" ; then --- > # FIXME: Temporary values for MPI_Offset (need help from IO subsystem) > if test "$cross_compiling" = "no" -a -n "$MPI_OFFSET_TYPE" ; then 5835a5846 > test/util/timer/Makefile \ diff -rN mpich2-1.0.7rc1/maint/simplemake.in bgp-mpich2/maint/simplemake.in 120c120 < $Sleep = $SleepFast; --- > $Sleep = $SleepSlow; diff -rN mpich2-1.0.7rc1/src/binding/f77/buildiface bgp-mpich2/src/binding/f77/buildiface 2116c2116 < $cchar = "C"; --- > $cchar = "!"; 2322,2323c2322,2323 < print MPIFFD " DOUBLE PRECISION MPI_WTIME, MPI_WTICK\n"; < print MPIFFD " DOUBLE PRECISION PMPI_WTIME, PMPI_WTICK\n"; --- > print MPIFFD " REAL*8 MPI_WTIME, MPI_WTICK\n"; > print MPIFFD " REAL*8 PMPI_WTIME, PMPI_WTICK\n"; diff -rN mpich2-1.0.7rc1/src/env/genmpxl.pl bgp-mpich2/src/env/genmpxl.pl 0a1,379 > #!/usr/bin/perl > > =head1 COPYRIGHT > > Product(s): > 5733-BG1 > > (C)Copyright IBM Corp. 2004, 2004 > All rights reserved. > US Government Users Restricted Rights - > Use, duplication or disclosure restricted > by GSA ADP Schedule Contract with IBM Corp. > > Licensed Materials-Property of IBM > > =cut > > my $COPYRIGHT = 'Licensed Materials - Property > of IBM, 5733-BG1 (C) COPYRIGHT 2004, 2004 > All Rights Reserved. US Government Users restricted Rights - > Use, Duplication or Disclosure restricted by GSA ADP Schedule > Contract with IBM Corp.'; > > > # This is a quick script to generate mpixl* from mpi{cc|cxx|f77} scripts and a single config file. > # Arguments are path-to-mpicc and path-to-this-script > # > # It is run in the MPI-level makefile > # smithbr: Do we need to change the text file stuff too maybe? > > use File::Copy; > > print "Creating mpixl* compiler scripts\n"; > $xlcomp_conf="mpixl.conf.in"; > if($ARGV[0] eq "") > { > print "Must provide location of existing bin/mpixxx and etc/mpixxx.conf\n"; > die; > } > > if($ARGV[1] eq "") > { > print "Must provide location of this script\n"; > die; > } > > $prefix_path=$ARGV[0]; > $script_path=$ARGV[1]; > if ($ARGV[2] ne "") { > $target=$ARGV[2]; > } > else { > $target="BGL"; > } > > if(! -e "$prefix_path/bin/mpicc") > { > print "Must provide location of existing bin/mpixxx and etc/mpixxx.conf\n"; > die; > } > > $mpicc="$prefix_path/bin/mpicc"; > $mpif77="$prefix_path/bin/mpif77"; > $mpicxx="$prefix_path/bin/mpicxx"; > > $mpixlc="$prefix_path/bin/mpixlc"; > $mpixlf77="$prefix_path/bin/mpixlf77"; > $mpixlcxx="$prefix_path/bin/mpixlcxx"; > $mpixlf90="$prefix_path/bin/mpixlf90"; > $mpixlf95="$prefix_path/bin/mpixlf95"; > $mpixlf2003="$prefix_path/bin/mpixlf2003"; > > if ($target eq "BGP") { > $mpixlc_r="$prefix_path/bin/mpixlc_r"; > $mpixlf77_r="$prefix_path/bin/mpixlf77_r"; > $mpixlcxx_r="$prefix_path/bin/mpixlcxx_r"; > $mpixlf90_r="$prefix_path/bin/mpixlf90_r"; > $mpixlf95_r="$prefix_path/bin/mpixlf95_r"; > $mpixlf2003_r="$prefix_path/bin/mpixlf2003_r"; > } > > # something to start with > > copy("$mpicc", "$mpixlc"); > copy("$mpicxx", "$mpixlcxx"); > copy("$mpif77", "$mpixlf77"); > copy("$mpif77", "$mpixlf90"); > copy("$mpif77", "$mpixlf95"); > copy("$mpif77", "$mpixlf2003"); > chmod(0755,$mpixlc); > chmod(0755,$mpixlcxx); > chmod(0755,$mpixlf77); > chmod(0755,$mpixlf90); > chmod(0755,$mpixlf95); > chmod(0755,$mpixlf2003); > > if ($target eq "BGP") { > copy("$mpicc", "$mpixlc_r"); > copy("$mpicxx", "$mpixlcxx_r"); > copy("$mpif77", "$mpixlf77_r"); > copy("$mpif77", "$mpixlf90_r"); > copy("$mpif77", "$mpixlf95_r"); > copy("$mpif77", "$mpixlf2003_r"); > chmod(0755,$mpixlc_r); > chmod(0755,$mpixlcxx_r); > chmod(0755,$mpixlf77_r); > chmod(0755,$mpixlf90_r); > chmod(0755,$mpixlf95_r); > chmod(0755,$mpixlf2003_r); > } > > # make sure xlcomp file is in $script_path... > if(! -e "$script_path/$xlcomp_conf") > { > print "Couldn't find $xlcomp_conf in $script_path\n"; > die; > } > > > # read in config variables > open CONF,"<$script_path/$xlcomp_conf" || die; > while() > { > if(/^(\w+)=(.*)/) > { > > # save the right xl compiler path, depending on whether it is BGP or BGL > > $vars{$1}=$2; > } > } > close CONF; > > # start replacing variables in the mpixl* scripts with variables read in from $xlcomp > open MPIXLC,">$mpixlc" || die; > if ($target eq "BGP") { > open MPIXLCR,">$mpixlc_r" || die; > } > open MPICC,"<$mpicc" || die; > while() > { > if(/^CC=/ && defined($vars{'XL9C'})) > { > $C9=$vars{'XL9C'}; > if ($target eq "BGL") { > $_="if [ -e $C9 ]; then\n"; > print MPIXLC $_; > $_="CC=$C9\n"; > print MPIXLC $_; > $_="else\n"; > print MPIXLC $_; > $_="CC=$vars{'XL8C'}\n"; > print MPIXLC $_; > $_="fi\n"; > print MPIXLC $_; > } > else { > $_="CC=$C9\n"; > print MPIXLC $_; > if (defined(MPIXLCR)) { > $_="CC=$vars{'XL9CR'}\n"; > print MPIXLCR $_; > } > } > } > else { > if(/^MPI_OTHERLIBS=/ && defined($vars{'MPI_OTHERLIBS'})) { > $_="MPI_OTHERLIBS=$vars{'MPI_OTHERLIBS'}\n"; > } > elsif(/^MPI_CFLAGS=/&& defined($vars{'MPI_CFLAGS'})) { > $_="MPI_CFLAGS=$vars{'MPI_CFLAGS'}\n"; > } > elsif(/^MPI_LDFLAGS=/ && defined($vars{'MPI_LDFLAGS'})) { > $_="MPI_LDFLAGS=$vars{'MPI_LDFLAGS'}\n"; > } > print MPIXLC $_; > if (defined(MPIXLCR)) { > print MPIXLCR $_; > } > } > } > close MPIXLC; > if (defined(MPIXLCR)) { > close MPIXLCR; > } > close MPICC; > > open MPIXLCXX,">$mpixlcxx" || die; > if ($target eq "BGP") { > open MPIXLCXXR, ">$mpixlcxx_r" || die; > } > open MPICXX,"<$mpicxx" || die; > while() > { > if(/^CXX=/ && defined($vars{'XL9CXX'})) > { > $C9XX=$vars{'XL9CXX'}; > if ($target eq "BGL") { > $_="if [ -e $C9XX ]; then\n"; > print MPIXLCXX $_; > $_="CXX=$C9XX\n"; > print MPIXLCXX $_; > $_="else\n"; > print MPIXLCXX $_; > $_="CXX=$vars{'XL8CXX'}\n"; > print MPIXLCXX $_; > $_="fi\n"; > print MPIXLCXX $_; > } > else { > $_="CXX=$C9XX\n"; > print MPIXLCXX $_; > } > if (defined(MPIXLCXXR)) { > $_="CXX=$vars{'XL9CXXR'}\n"; > print MPIXLCXXR $_; > } > } > else { > if(/^MPI_OTHERLIBS=/ && defined($vars{'MPI_OTHERLIBS'})) { > $_="MPI_OTHERLIBS=$vars{'MPI_OTHERLIBS'}\n"; > } > elsif(/^MPI_CXXFLAGS=/ && defined($vars{'MPI_CXXFLAGS'})) { > $_="MPI_CXXFLAGS=$vars{'MPI_CXXFLAGS'}\n"; > } > elsif(/^MPI_LDFLAGS=/ && defined($vars{'MPI_LDFLAGS'})) { > $_="MPI_LDFLAGS=$vars{'MPI_LDFLAGS'}\n"; > } > print MPIXLCXX $_; > if (defined(MPIXLCXXR)) { > print MPIXLCXXR $_; > } > } > > } > close MPIXLCXX; > if (defined(MPIXLCXXR)) { > close MPIXLCXXR; > } > close MPICXX; > > open MPIXLF77,">$mpixlf77" || die; > open MPIXLF90, ">$mpixlf90" || die; > open MPIXLF95, ">$mpixlf95" || die; > open MPIXLF2003, ">$mpixlf2003" || die; > if ($target eq "BGP") { > open MPIXLF77R,">$mpixlf77_r" || die; > open MPIXLF90R, ">$mpixlf90_r" || die; > open MPIXLF95R, ">$mpixlf95_r" || die; > open MPIXLF2003R, ">$mpixlf2003_r" || die; > } > > open MPIF77,"<$mpif77" || die; > while() > { > if (/^F77=/) { > $FCOMP='F77'; > } > elsif (/^FC=/) { > $FCOMP='FC'; > } > else { > $FCOMP=''; > } > if ($FCOMP ne '') { > $F11=$vars{'XL11F77'}; > if ($target eq "BGL") { > $_="if [ -e $F11 ]; then\n"; > print MPIXLF77 $_; > $_="$FCOMP=$F11\n"; > print MPIXLF77 $_; > $_="else\n"; > print MPIXLF77 $_; > $_="$FCOMP=$vars{'XL10F77'}\n"; > print MPIXLF77 $_; > $_="fi\n"; > print MPIXLF77 $_; > } > else { > $_="$FCOMP=$vars{'XL11F77'}\n"; > print MPIXLF77 $_; > if (defined('XL11F77R')) { > $_="$FCOMP=$vars{'XL11F77R'}\n"; > print MPIXLF77R $_; > } > } > $F11=$vars{'XL11F90'}; > if ($target eq "BGL") { > $_="if [ -e $F11 ]; then\n"; > print MPIXLF90 $_; > $_="$FCOMP=$F11\n"; > print MPIXLF90 $_; > $_="else\n"; > print MPIXLF90 $_; > $_="$FCOMP=$vars{'XL10F90'}\n"; > print MPIXLF90 $_; > $_="fi\n"; > print MPIXLF90 $_; > } > else { > $_="$FCOMP=$F11\n"; > print MPIXLF90 $_; > if (defined($vars{'XL11F90R'})) { > $_="$FCOMP=$vars{'XL11F90R'}\n"; > print MPIXLF90R $_; > } > } > $F11=$vars{'XL11F95'}; > if ($target eq "BGL") { > $_="if [ -e $F11 ]; then\n"; > print MPIXLF95 $_; > $_="$FCOMP=$F11\n"; > print MPIXLF95 $_; > $_="else\n"; > print MPIXLF95 $_; > $_="$FCOMP=$vars{'XL10F95'}\n"; > print MPIXLF95 $_; > $_="fi\n"; > print MPIXLF95 $_; > } > else { > $_="$FCOMP=$vars{'XL11F95'}\n"; > print MPIXLF95 $_; > if (defined($vars{'XL11F95R'})) { > $_="$FCOMP=$vars{'XL11F95R'}\n"; > print MPIXLF95R $_; > } > } > if (defined($vars{'XL11F2003'})) { > $_="$FCOMP=$vars{'XL11F2003'}\n"; > print MPIXLF2003 $_; > if (defined($vars{'XL11F2003R'})) { > $_="$FCOMP=$vars{'XL11F2003R'}\n"; > print MPIXLF2003R $_; > } > } > } > else { > if(/^MPI_OTHERLIBS=/ && defined($vars{'MPI_OTHERLIBS'})) { > $_="MPI_OTHERLIBS=$vars{'MPI_OTHERLIBS'}\n"; > } > elsif(/^MPI_LDFLAGS=/ && defined($vars{'MPI_LDFLAGS'})) { > $_="MPI_LDFLAGS=$vars{'MPI_LDFLAGS'}\n"; > } > elsif(/^F77CPP=/ && defined($vars{'F77CPP'})) { > $_="F77CPP=$vars{'F77CPP'}\n"; > } > > elsif(/^MPI_FFLAGS=/ && defined($vars{'MPI_FFLAGS'})) { > $_="MPI_FFLAGS=$vars{'MPI_FFLAGS'}\n"; > } > > print MPIXLF77 $_; > print MPIXLF90 $_; > print MPIXLF95 $_; > print MPIXLF2003 $_; > > if ($target eq "BGP") { > print MPIXLF77R $_; > print MPIXLF90R $_; > print MPIXLF95R $_; > print MPIXLF2003R $_; > } > } > } > close MPIXLF77; > close MPIXLF90; > close MPIXLF95; > close MPIXLF2003; > > if ($target eq "BGP") { > close MPIXLF77R; > close MPIXLF90R; > close MPIXLF95R; > close MPIXLF2003R; > } > close MPIF77; > > print "Done\n"; diff -rN mpich2-1.0.7rc1/src/env/mpixl.conf.in bgp-mpich2/src/env/mpixl.conf.in 0a1,40 > #! /bin/sh > # > # This file contains configuration information for mpicc. This is > # essentially just the variable-initialization part of mpicc. > # -------------------------------------------------------------------------- > # Set the default values of all variables. > # > # Directory locations: Fixed for any MPI implementation. > # Set from the directory arguments to configure (e.g., --prefix=/usr/local) > # > # Default settings for compiler, flags, and libraries. > # Determined by a combination of environment variables and tests within > # configure (e.g., determining whehter -lsocket is needee) > > XL9C="/opt/ibmcmp/vacpp/bg/9.0/bin/bgxlc" > XL9CXX="/opt/ibmcmp/vacpp/bg/9.0/bin/bgxlC" > XL11F77="/opt/ibmcmp/xlf/bg/11.1/bin/bgxlf" > XL11F90="/opt/ibmcmp/xlf/bg/11.1/bin/bgxlf90" > XL11F95="/opt/ibmcmp/xlf/bg/11.1/bin/bgxlf95" > XL11F2003="/opt/ibmcmp/xlf/bg/11.1/bin/bgxlf2003" > > XL9CR="/opt/ibmcmp/vacpp/bg/9.0/bin/bgxlc_r" > XL9CXXR="/opt/ibmcmp/vacpp/bg/9.0/bin/bgxlC_r" > XL11F77R="/opt/ibmcmp/xlf/bg/11.1/bin/bgxlf_r" > XL11F90R="/opt/ibmcmp/xlf/bg/11.1/bin/bgxlf90_r" > XL11F95R="/opt/ibmcmp/xlf/bg/11.1/bin/bgxlf95_r" > XL11F2003R="/opt/ibmcmp/xlf/bg/11.1/bin/bgxlf2003_r" > > # No threads in BGL, so no thread-safe compilers. > > XL8C="/opt/ibmcmp/vacpp/bg/8.0/bin/blrts_xlc" > XL8CXX="/opt/ibmcmp/vacpp/bg/8.0/bin/blrts_xlC" > XL10F77="/opt/ibmcmp/xlf/bg/10.1/bin/blrts_xlf" > XL10F90="/opt/ibmcmp/xlf/bg/10.1/bin/blrts_xlf90" > XL10F95="/opt/ibmcmp/xlf/bg/10.1/bin/blrts_xlf95" > > MPI_CFLAGS="" > MPI_CXXFLAGS="" > MPI_FFLAGS="" > F77CPP="" diff -rN mpich2-1.0.7rc1/src/include/mpiimpl.h bgp-mpich2/src/include/mpiimpl.h 73a74,79 > /* Include definitions from the device which must exist before items in this > file (mpiimpl.h) can be defined. */ > /* ------------------------------------------------------------------------- */ > #include "mpidpre.h" > /* ------------------------------------------------------------------------- */ > 96,100d101 < /* Include definitions from the device which must exist before items in this < file (mpiimpl.h) can be defined. */ < /* ------------------------------------------------------------------------- */ < #include "mpidpre.h" < /* ------------------------------------------------------------------------- */ 1365a1367,1369 > > MPID_Request __totalview_request_dummyvar; > diff -rN mpich2-1.0.7rc1/src/include/mpiimplthread.h bgp-mpich2/src/include/mpiimplthread.h 141a142 > MPIR_Nest_incr(); \ diff -rN mpich2-1.0.7rc1/src/mpe/Build-MPE-on-blrts bgp-mpich2/src/mpe/Build-MPE-on-blrts 0a1,79 > #!/bin/bash > > export CC_RTS=${CC_RTS-/BlueLight/floor/blrts-gnu/bin/powerpc-bgl-blrts-gnu-gcc} > export F77_RTS=${F77_RTS-/BlueLight/floor/blrts-gnu/bin/powerpc-bgl-blrts-gnu-g77} > > if [ -z "$BGL_SYSROOT" ]; then > err=1; > echo "Need to set BGL_SYSROOT first..." > fi > > if [ -z "$CC_RTS" ]; then > err=1; > echo "Need to set CC_RTS first..." > fi > > if [ -z "$F77_RTS" ]; then > err=1; > echo "Need to set F77_RTS first..." > fi > > if [ $err ]; then > exit 1 > fi > > cat << EOF > Using > CC_RTS=$CC_RTS > F77_RTS=$F77_RTS > BGL_SYSROOT=$BGL_SYSROOT > EOF > > bdir=../../../build-mpe > mkdir $bdir || (echo "Remove build dir $bdir first." ; exit 1) || exit 1 > > cd $bdir || exit > > echo "Doing configure in directory `pwd`" > echo "" > > # Variables needed for the MPE cross compile > export MPI_CC=$BGL_SYSROOT/bin/mpicc > export MPI_F77=$BGL_SYSROOT/bin/mpif77 > export CC=$CC_RTS > export F77=$F77_RTS > > export F2CMPI_LIBS=-lfmpich > export CROSS_BIGENDIAN=true # true if it is a big endian machine, false otherwise. > export CROSS_MPI_STATUS_SIZE=5 # value of MPI_STATUS_SIZE defined in mpif.h, > export CROSS_FORTRAN2C_TRUE=1 # value of fortran's .TRUE. in C program, e.g. 1 > export CROSS_FORTRAN2C_FALSE=0 # value of fortran's .FALSE. in C program, e.g. 0 > #export CROSS_SIZEOF_CHAR=1 # sizeof(char), e.g. 1 > #export CROSS_SIZEOF_SHORT=2 # sizeof(short), e.g. 2 > #export CROSS_SIZEOF_INT=4 # sizeof(int), e.g. 4 > #export CROSS_SIZEOF_LONG_LONG=8 # sizeof(long long), e.g. 8 > > > ../mpich2/src/mpe/configure --disable-mpe_graphics --disable-viewer --without-java --prefix=$BGL_SYSROOT --host=powerpc-bgl-blrts-gnu --target=powerpc-bgl-blrts-gnu --build=i686-linux-gnu --enable-g=none --enable-sharedlibs=none --with-device=bgltorus4 --with-pmi=bgltorus_simple > > # Finally fix the last bug in configure I never was able to figure out... > echo "Now, edit mpeconfig.h to make Fortraqn name mangling right!" > mv mpeconf.h mpeconf.h.ORIG > sed 's/F77_NAME_LOWER_2USCORE/F77_NAME_LOWER/' mpeconf.h.ORIG > mpeconf.h > > echo diff mpeconf.h.ORIG mpeconf.h > > # Check that you can make a diff and that there is a difference (exit status =1) > diff mpeconf.h.ORIG mpeconf.h > [ $? -eq 1 ] || exit 1 > > make > > cat << EOF > > If the make completed OK you might now want to do: > > cd `pwd` > make install > > EOF diff -rN mpich2-1.0.7rc1/src/mpi/comm/commutil.c bgp-mpich2/src/mpi/comm/commutil.c 189,192c189 < < /* Both the threaded and non-threaded routines use the same mask of available < context id values. */ < #define MAX_CONTEXT_MASK 32 --- > #define MAX_CONTEXT_MASK 256 diff -rN mpich2-1.0.7rc1/src/mpi/datatype/get_elements.c bgp-mpich2/src/mpi/datatype/get_elements.c 196a197,198 > if(datatype_ptr->contents == NULL) > return MPI_ERR_TYPE; 198a201,202 > if(types == NULL) > return MPI_ERR_TYPE; 200a205,206 > if(ints == NULL) > return MPI_ERR_TYPE; 202a209,210 > if(aints == NULL) > return MPI_ERR_TYPE; diff -rN mpich2-1.0.7rc1/src/mpi/romio/adio/ad_bgl/ad_bgl_aggrs.c bgp-mpich2/src/mpi/romio/adio/ad_bgl/ad_bgl_aggrs.c 0a1,976 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file ad_bgl_aggrs.c > * \brief The externally used function from this file is is declared in ad_bgl_aggrs.h > */ > > /* -*- Mode: C; c-basic-offset:4 ; -*- */ > /* > * Copyright (C) 1997 University of Chicago. > * See COPYRIGHT notice in top-level directory. > */ > > #include "adio.h" > #include "adio_cb_config_list.h" > #include "ad_bgl.h" > #include "ad_bgl_pset.h" > #include "ad_bgl_aggrs.h" > > > int aggrsInPsetSize=0; > int *aggrsInPset=NULL; > > /* forward declaration */ > static void > ADIOI_BGL_compute_agg_ranklist_serial ( ADIO_File fd, > const ADIOI_BGL_ConfInfo_t *confInfo, > ADIOI_BGL_ProcInfo_t *all_procInfo, > int *aggrsInPset ); > > /* > * Compute the aggregator-related parameters that are required in 2-phase collective IO of ADIO. > * The parameters are > * . the number of aggregators (proxies) : fd->hints->cb_nodes > * . the ranks of the aggregators : fd->hints->ranklist > * By compute these two parameters in a BGL-PSET-aware way, the default 2-phase collective IO of > * ADIO can work more efficiently. > */ > int > ADIOI_BGL_gen_agg_ranklist(ADIO_File fd, int n_aggrs_per_pset) > { > int r, s; > ADIOI_BGL_ProcInfo_t *procInfo, *all_procInfo; > ADIOI_BGL_ConfInfo_t *confInfo; > > MPI_Comm_size( fd->comm, &s ); > MPI_Comm_rank( fd->comm, &r ); > > /* Collect individual BGL personality information */ > confInfo = ADIOI_BGL_ConfInfo_new (); > procInfo = ADIOI_BGL_ProcInfo_new (); > ADIOI_BGL_persInfo_init( confInfo, procInfo, s, r, n_aggrs_per_pset ); > > /* Gather BGL personality infomation onto process 0 */ > // if (r == 0) > all_procInfo = ADIOI_BGL_ProcInfo_new_n (s); > if(s > aggrsInPsetSize) > { > if(aggrsInPset) ADIOI_Free(aggrsInPset); > aggrsInPset = (int *) ADIOI_Malloc (s *sizeof(int)); > aggrsInPsetSize = s; > } > > > MPI_Gather( (void *)procInfo, sizeof(ADIOI_BGL_ProcInfo_t), MPI_BYTE, > (void *)all_procInfo, sizeof(ADIOI_BGL_ProcInfo_t), MPI_BYTE, > 0, > fd->comm ); > > /* Compute a list of the ranks of chosen IO proxy CN on process 0 */ > if (r == 0) { > ADIOI_BGL_compute_agg_ranklist_serial (fd, confInfo, all_procInfo, aggrsInPset); > // ADIOI_BGL_ProcInfo_free (all_procInfo); > } > ADIOI_BGL_ProcInfo_free (all_procInfo); > > /* Send the info of IO proxy CN to all processes and keep the info in fd->hints struct. > Declared in adio_cb_config_list.h */ > ADIOI_cb_bcast_rank_map(fd); > > /* Broadcast the BGL-GPFS related file domain info */ > MPI_Bcast( (void *)aggrsInPset, > fd->hints->cb_nodes * sizeof(int), MPI_BYTE, > 0, > fd->comm ); > > ADIOI_BGL_persInfo_free( confInfo, procInfo ); > return 0; > } > > /* > * the purpose of abstracting out this routine is to make it easy for trying different proxy-selection criteria. > */ > static int > ADIOI_BGL_select_agg_in_pset (const ADIOI_BGL_ConfInfo_t *confInfo, > ADIOI_BGL_ProcInfo_t *pset_procInfo, > int nCN_in_pset, > int *tmp_ranklist) > { > /* first implementation, based on their rank order. */ > > int i, j, k; > > /* The number of aggregators in the PSET is proportional to the CNs in the PSET */ > int nAggrs = nCN_in_pset * confInfo->aggRatio; > if (nAggrs < ADIOI_BGL_NAGG_PSET_MIN) nAggrs = ADIOI_BGL_NAGG_PSET_MIN; > > /* for not virtual-node-mode, pick aggregators in this PSET based on the order of the global rank */ > if (!confInfo->isVNM) > { > for (i=0; i } > > /* for virtual-node-mode, first pick aggregators among CPU-0 */ > else > { > /* Try to pick from CPU-0 first, then CPU-1, then ... CPU-n */ > j = 0; > for (k=0; k < confInfo->cpuidSize; k++){ > for (i=0; i< nCN_in_pset ; i++) { > if (pset_procInfo[i].cpuid == k) > tmp_ranklist[j++] = pset_procInfo[i].rank; > if ( j >= nAggrs) break; > } > if ( j >= nAggrs) break; > } > } > > return nAggrs; > } > > /* > * Pick IO aggregators based on the under PSET organization and stores the ranks of the proxy CNs in tmp_ranklist. > * The first order of tmp_ranklist is : PSET number > * The secondary order of the list is determined in ADIOI_BGL_select_agg_in_pset() and thus adjustable. > */ > static int > ADIOI_BGL_compute_agg_ranklist_serial_do (const ADIOI_BGL_ConfInfo_t *confInfo, > ADIOI_BGL_ProcInfo_t *all_procInfo, > int *aggrsInPset, > int *tmp_ranklist) > { > int i, j; > > /* a list of the numbers of all the PSETS */ > int *psetNumList = (int *) ADIOI_Malloc ( confInfo->nProcs * sizeof(int) ); > > /* sweep through all processes' records, collect the numbers of all the PSETS. > * The reason for not doing MIN, MAX is that the owned PSETs may not have contiguous numbers */ > int n_psets=0; > for (i=0; inProcs; i++) { > > ADIOI_BGL_ProcInfo_t *info_p = all_procInfo+i; > > int exist = 0; > for (j=n_psets-1; j>=0; j--) > if (info_p->psetNum == psetNumList[j]) { exist=1; break; } > > if (!exist) { > psetNumList [n_psets] = info_p->psetNum; > n_psets ++; > } > } > > /* bucket sort: put the CN nodes into ordered buckets, each of which represents a PSET */ > > /* bucket space for bucket sort */ > ADIOI_BGL_ProcInfo_t *sorted_procInfo = ADIOI_BGL_ProcInfo_new_n ( n_psets * confInfo->virtualPsetSize ); > int *PsetIdx = (int *) ADIOI_Malloc ( n_psets * sizeof(int) ); > AD_BGL_assert ( (PsetIdx != NULL) ); > > /* initialize bucket pointer */ > for (i=0; i PsetIdx[i] = i*confInfo->virtualPsetSize; > } > > /* sort */ > for (i=0; inProcs; i++) { > int pset_id = all_procInfo[i].psetNum; > > for (j=n_psets-1; j>=0; j--) if (pset_id == psetNumList[j]) break; > AD_BGL_assert ( (j >= 0) ); /* got to find a PSET bucket */ > > sorted_procInfo[ PsetIdx[j] ++ ] = all_procInfo[i]; > } > > ADIOI_Free(psetNumList); > > /* select a number of CN aggregators from each Pset */ > int naggs = 0; > for (i=0; i > /* the number of CN in this PSET -- may not be a full PSET */ > int nCN_in_pset = PsetIdx[i] - i*confInfo->virtualPsetSize; > > /* select aggregators and put them into tmp_ranklist contiguously. */ > int local_naggs = ADIOI_BGL_select_agg_in_pset( confInfo, > sorted_procInfo + i*confInfo->virtualPsetSize, > nCN_in_pset, > tmp_ranklist + naggs); > aggrsInPset[i+1] = local_naggs; > > naggs += local_naggs; > } > aggrsInPset[0] = n_psets; > > /* leave */ > ADIOI_Free ( PsetIdx ); > ADIOI_BGL_ProcInfo_free ( sorted_procInfo ); > return naggs; > } > > /* > * compute aggregators ranklist and put it into fd->hints struct > */ > static void > ADIOI_BGL_compute_agg_ranklist_serial ( ADIO_File fd, > const ADIOI_BGL_ConfInfo_t *confInfo, > ADIOI_BGL_ProcInfo_t *all_procInfo, > int *aggrsInPset ) > { > # define DEBUG 0 > # if DEBUG > int i; > # endif > int naggs; > int *tmp_ranklist; > > /* compute the ranklist of IO aggregators and put into tmp_ranklist */ > tmp_ranklist = (int *) ADIOI_Malloc (confInfo->nProcs * sizeof(int)); > > # if DEBUG > for (i=0; inProcs; i++) > printf( "\tcpuid %1d, rank = %6d\n", all_procInfo[i].cpuid, all_procInfo[i].rank ); > # endif > > naggs = > ADIOI_BGL_compute_agg_ranklist_serial_do (confInfo, all_procInfo, aggrsInPset, tmp_ranklist); > > # define VERIFY 0 > # if VERIFY > printf( "\tconfInfo = %3d,%3d,%3d,%3d,%3d,%3d,%.4f; naggs = %d\n", > confInfo->PsetSize , > confInfo->numPsets , > confInfo->isVNM , > confInfo->virtualPsetSize , > confInfo->nProcs , > confInfo->nAggrs , > confInfo->aggRatio , > naggs ); > # endif > > # if DEBUG > for (i=0; i printf( "\taggr %-4d = %6d\n", i, tmp_ranklist[i] ); > # endif > > /* copy the ranklist of IO aggregators to fd->hints */ > if(fd->hints->ranklist != NULL) ADIOI_Free (fd->hints->ranklist); > > fd->hints->cb_nodes = naggs; > fd->hints->ranklist = (int *) ADIOI_Malloc (naggs * sizeof(int)); > memcpy( fd->hints->ranklist, tmp_ranklist, naggs*sizeof(int) ); > > /* */ > ADIOI_Free( tmp_ranklist ); > return; > } > > > > /* > * Compute a dynamic access range based file domain partition among I/O aggregators, > * which align to the GPFS block size > * Divide the I/O workload among "nprocs_for_coll" processes. This is > * done by (logically) dividing the file into file domains (FDs); each > * process may directly access only its own file domain. > * Additional effort is to make sure that each I/O aggregator get > * a file domain that aligns to the GPFS block size. So, there will > * not be any false sharing of GPFS file blocks among multiple I/O nodes. > */ > void ADIOI_BGL_GPFS_Calc_file_domains(ADIO_Offset *st_offsets, > ADIO_Offset *end_offsets, > int nprocs, > int nprocs_for_coll, > ADIO_Offset *min_st_offset_ptr, > ADIO_Offset **fd_start_ptr, > ADIO_Offset **fd_end_ptr, > ADIO_Offset *fd_size_ptr, > void *fs_ptr) > { > ADIO_Offset min_st_offset, max_end_offset, *fd_start, *fd_end, *fd_size; > int i, aggr; > static char myname[] = "ADIOI_BGL_GPFS_Calc_file_domains"; > __blksize_t blksize = 1048576; /* default to 1M */ > if(fs_ptr && ((ADIOI_BGL_fs*)fs_ptr)->blksize) /* ignore null ptr or 0 blksize */ > blksize = ((ADIOI_BGL_fs*)fs_ptr)->blksize; > /* FPRINTF(stderr,"%s(%d): Blocksize=%ld\n",myname,__LINE__,blksize);*/ > > /* find the range of all the requests */ > min_st_offset = st_offsets [0]; > max_end_offset = end_offsets[0]; > for (i=1; i min_st_offset = ADIOI_MIN(min_st_offset, st_offsets[i]); > max_end_offset = ADIOI_MAX(max_end_offset, end_offsets[i]); > } > > // printf( "_calc_file_domains, min_st_offset, max_ = %qd, %qd\n", min_st_offset, max_end_offset ); > > /* determine the "file domain (FD)" of each process, i.e., the portion of > the file that will be "owned" by each process */ > > ADIO_Offset gpfs_ub = (max_end_offset +blksize-1) / blksize * blksize - 1; > ADIO_Offset gpfs_lb = min_st_offset / blksize * blksize; > ADIO_Offset gpfs_ub_rdoff = (max_end_offset +blksize-1) / blksize * blksize - 1 - max_end_offset; > ADIO_Offset gpfs_lb_rdoff = min_st_offset - min_st_offset / blksize * blksize; > ADIO_Offset fd_gpfs_range = gpfs_ub - gpfs_lb + 1; > > int naggs = nprocs_for_coll; > fd_size = (ADIO_Offset *) ADIOI_Malloc(nprocs_for_coll * sizeof(ADIO_Offset)); > *fd_start_ptr = (ADIO_Offset *) ADIOI_Malloc(nprocs_for_coll * sizeof(ADIO_Offset)); > *fd_end_ptr = (ADIO_Offset *) ADIOI_Malloc(nprocs_for_coll * sizeof(ADIO_Offset)); > fd_start = *fd_start_ptr; > fd_end = *fd_end_ptr; > > ADIO_Offset n_gpfs_blk = fd_gpfs_range / blksize; > ADIO_Offset nb_cn_small = n_gpfs_blk/naggs; > ADIO_Offset naggs_large = n_gpfs_blk - naggs * (n_gpfs_blk/naggs); > ADIO_Offset naggs_small = naggs - naggs_large; > > for (i=0; i if (i < naggs_small) fd_size[i] = nb_cn_small * blksize; > else fd_size[i] = (nb_cn_small+1) * blksize; > > /* FPRINTF(stderr,"%s(%d): " > "gpfs_ub %llu, " > "gpfs_lb %llu, " > "gpfs_ub_rdoff %llu, " > "gpfs_lb_rdoff %llu, " > "fd_gpfs_range %llu, " > "n_gpfs_blk %llu, " > "nb_cn_small %llu, " > "naggs_large %llu, " > "naggs_small %llu, " > "\n", > myname,__LINE__, > gpfs_ub , > gpfs_lb , > gpfs_ub_rdoff, > gpfs_lb_rdoff, > fd_gpfs_range, > n_gpfs_blk , > nb_cn_small , > naggs_large , > naggs_small > ); > */ > fd_size[0] -= gpfs_lb_rdoff; > fd_size[naggs-1] -= gpfs_ub_rdoff; > > /* compute the file domain for each aggr */ > ADIO_Offset offset = min_st_offset; > for (aggr=0; aggr fd_start[aggr] = offset; > fd_end [aggr] = offset + fd_size[aggr] - 1; > offset += fd_size[aggr]; > } > > *fd_size_ptr = fd_size[0]; > *min_st_offset_ptr = min_st_offset; > > ADIOI_Free (fd_size); > } > > > /* > * deprecated > * > void ADIOI_BGL_GPFS_Calc_file_domain0(ADIO_Offset *st_offsets, > ADIO_Offset *end_offsets, > int nprocs, > int nprocs_for_coll, > ADIO_Offset *min_st_offset_ptr, > ADIO_Offset **fd_start_ptr, > ADIO_Offset **fd_end_ptr, > ADIO_Offset *fd_size_ptr) > { > ADIO_Offset min_st_offset, max_end_offset, *fd_start, *fd_end, *fd_size; > int i; > static int GPFS_BSIZE=1048576; > * find the range of all the requests * > min_st_offset = st_offsets [0]; > max_end_offset = end_offsets[0]; > for (i=1; i min_st_offset = ADIOI_MIN(min_st_offset, st_offsets[i]); > max_end_offset = ADIOI_MAX(max_end_offset, end_offsets[i]); > } > > * determine the "file domain (FD)" of each process, i.e., the portion of > the file that will be "owned" by each process * > > * GPFS specific, pseudo starting/end point has to round to GPFS_BSIZE * > ADIO_Offset gpfs_ub = (max_end_offset +GPFS_BSIZE-1) / GPFS_BSIZE * GPFS_BSIZE - 1; > ADIO_Offset gpfs_lb = min_st_offset / GPFS_BSIZE * GPFS_BSIZE; > ADIO_Offset gpfs_ub_rdoff = (max_end_offset +GPFS_BSIZE-1) / GPFS_BSIZE * GPFS_BSIZE - 1 - max_end_offset; > ADIO_Offset gpfs_lb_rdoff = min_st_offset - min_st_offset / GPFS_BSIZE * GPFS_BSIZE; > ADIO_Offset fd_gpfs_range = gpfs_ub - gpfs_lb + 1; > > * all computation of partition is based on the rounded pseudo-range * > ADIO_Offset fds_ub = (fd_gpfs_range +nprocs_for_coll-1) / nprocs_for_coll; > ADIO_Offset fds_lb = fd_gpfs_range / nprocs_for_coll; > int naggs = nprocs_for_coll; > int npsets = aggrsInPset[0]; * special meaning for element 0 * > fd_size = (ADIO_Offset *) ADIOI_Malloc(naggs * sizeof(ADIO_Offset)); > *fd_start_ptr = (ADIO_Offset *) ADIOI_Malloc(naggs * sizeof(ADIO_Offset)); > *fd_end_ptr = (ADIO_Offset *) ADIOI_Malloc(naggs * sizeof(ADIO_Offset)); > fd_start = *fd_start_ptr; > fd_end = *fd_end_ptr; > > * some pre-computation to determine rough ratio of when to up-fit, when to low-fit * > * 1. get the estimated data per pset * > * 2. determine a factor between up and down * > int avg_aggrsInPset = (naggs +npsets-1)/npsets; > ADIO_Offset avg_bytes_perPset = fd_gpfs_range / npsets; > ADIO_Offset resid = avg_bytes_perPset % GPFS_BSIZE; > ADIO_Offset downr = GPFS_BSIZE - resid; > int small = (resid < downr); > int ratio = downr == 0 ? npsets + 2 : (resid +downr-1)/downr; > if (small) ratio = resid == 0 ? npsets + 2 : (downr +resid-1)/resid; > > > * go through aggrsInfo of all PSETs * > ADIO_Offset fd_range = fd_gpfs_range; > int aggr = 0, pset; > for (pset=0; pset > ADIO_Offset fds_try = fds_lb; > int my_naggs = aggrsInPset[pset+1]; > ADIO_Offset fds_pset; > > * Last pset will deal with the residuals * > if (pset == npsets-1) > fds_pset = fd_range; > else > { > int cond1 = ((pset+1) % ratio == 0); > int cond2 = ((pset+1) % ratio != 0); > > if (small) { > int temp = cond1; cond1 = cond2; cond2 = temp; > } > > if (cond1) { > fds_pset = fds_try * my_naggs; > if (fds_pset % GPFS_BSIZE) // align to GPFS_BSIZE > fds_pset = ((fds_pset +GPFS_BSIZE-1)/GPFS_BSIZE) * GPFS_BSIZE; > } > if (cond2) > { > fds_try = fds_ub; > fds_pset = fds_try * my_naggs; > if (fds_pset % GPFS_BSIZE) // align to GPFS_BSIZE > fds_pset = (fds_pset / GPFS_BSIZE) * GPFS_BSIZE; > } > } > > * for aggrs in each PSET, divide evenly the data range * > #define CN_ALIGN 1 > #if !CN_ALIGN > fd_range -= fds_pset; > if ( pset == 0 ) fds_pset -= gpfs_lb_rdoff; > if ( pset == npsets-1 ) fds_pset -= gpfs_ub_rdoff; > int p; > for (p=0; p fd_size[aggr] = (fds_pset +my_naggs-1) / my_naggs; > if (p== my_naggs-1) > fd_size[aggr] -= (fd_size[aggr]*my_naggs - fds_pset); > > aggr++; > } > #else > ADIO_Offset avg_bytes_perP = fds_pset / my_naggs; > ADIO_Offset resid2 = avg_bytes_perP % GPFS_BSIZE; > ADIO_Offset downr2 = GPFS_BSIZE - resid2; > int small2 = (resid2 < downr2); > int ratio2 = downr2 == 0 ? my_naggs + 2 : (resid2 +downr2-1)/downr2; > if (small2) ratio2 = resid2 == 0 ? my_naggs + 2 : (downr2 +resid2-1)/resid2; > ADIO_Offset accu = 0; > int p; > for (p=0; p int cond1 = ((p+1) % ratio2 == 0); > int cond2 = ((p+1) % ratio2 != 0); > if (small2) { > int temp = cond1; cond1 = cond2; cond2 = temp; > } > fd_size[aggr] = avg_bytes_perP; > if (cond2) fd_size[aggr] = ((fd_size[aggr] +GPFS_BSIZE-1)/GPFS_BSIZE) * GPFS_BSIZE; > if (cond1) fd_size[aggr] = ((fd_size[aggr] )/GPFS_BSIZE) * GPFS_BSIZE; > if (p== my_naggs-1) > fd_size[aggr] = (fds_pset - accu); > > accu += fd_size[aggr]; > fd_range -= fd_size[aggr]; > aggr++; > } > #endif > } > > * after scheduling, the first and the last region has to remove the round-off effect * > > #if CN_ALIGN > fd_size[0] -= gpfs_lb_rdoff; > fd_size[naggs-1] -= gpfs_ub_rdoff; > #endif > > * compute the file domain for each aggr * > ADIO_Offset offset = min_st_offset; > for (aggr=0; aggr fd_start[aggr] = offset; > fd_end [aggr] = offset + fd_size[aggr] - 1; > offset += fd_size[aggr]; > } > > * > printf( "\t%6d : %12qd:%12qd, %12qd:%12qd:%12qd, %12qd:%12qd:%12qd\n", > naggs, > min_st_offset, > max_end_offset, > fd_start[0], > fd_end [0], > fd_size [0], > fd_start[naggs-1], > fd_end [naggs-1], > fd_size [naggs-1] ); > * > > > *fd_size_ptr = fd_size[0]; > *min_st_offset_ptr = min_st_offset; > > ADIOI_Free (fd_size); > } > */ > > /* > * When a process is an IO aggregator, this will return its index in the aggrs list. > * Otherwise, this will return -1 > */ > int ADIOI_BGL_Aggrs_index( ADIO_File fd, int myrank ) > { > int i; > for (i=0; ihints->cb_nodes; i++) > if (fd->hints->ranklist[i] == myrank) return i; > return -1; > } > > /* > * This is more general aggregator search function which does not base on the assumption > * that each aggregator hosts the file domain with the same size > */ > int ADIOI_BGL_Calc_aggregator(ADIO_File fd, > ADIO_Offset off, > ADIO_Offset min_off, > ADIO_Offset *len, > ADIO_Offset fd_size, > ADIO_Offset *fd_start, > ADIO_Offset *fd_end) > { > int rank_index, rank; > ADIO_Offset avail_bytes; > > AD_BGL_assert ( (off <= fd_end[fd->hints->cb_nodes-1] && off >= min_off && fd_start[0] >= min_off ) ); > > /* binary search --> rank_index is returned */ > int ub = fd->hints->cb_nodes; > int lb = 0; > rank_index = fd->hints->cb_nodes / 2; > while ( off < fd_start[rank_index] || off > fd_end[rank_index] ) { > if ( off > fd_end [rank_index] ) { > lb = rank_index; > rank_index = (rank_index + ub) / 2; > } > else > if ( off < fd_start[rank_index] ) { > ub = rank_index; > rank_index = (rank_index + lb) / 2; > } > } > > // printf ("ADIOI_BGL_Calc_aggregator: rank_index = %d\n", rank_index ); > > /* > * remember here that even in Rajeev's original code it was the case that > * different aggregators could end up with different amounts of data to > * aggregate. here we use fd_end[] to make sure that we know how much > * data this aggregator is working with. > * > * the +1 is to take into account the end vs. length issue. > */ > avail_bytes = fd_end[rank_index] + 1 - off; > if (avail_bytes < *len && avail_bytes > 0) { > /* this file domain only has part of the requested contig. region */ > > *len = avail_bytes; > } > > /* map our index to a rank */ > /* NOTE: FOR NOW WE DON'T HAVE A MAPPING...JUST DO 0..NPROCS_FOR_COLL */ > rank = fd->hints->ranklist[rank_index]; > > return rank; > } > > > /* > * ADIOI_BGL_Calc_my_req() overrides ADIOI_Calc_my_req for the default implementation > * is specific for static file domain partitioning. > * > * ADIOI_Calc_my_req() calculate what portions of the access requests > * of this process are located in the file domains of various processes > * (including this one) > */ > void ADIOI_BGL_Calc_my_req(ADIO_File fd, ADIO_Offset *offset_list, int *len_list, > int contig_access_count, ADIO_Offset > min_st_offset, ADIO_Offset *fd_start, > ADIO_Offset *fd_end, ADIO_Offset fd_size, > int nprocs, > int *count_my_req_procs_ptr, > int **count_my_req_per_proc_ptr, > ADIOI_Access **my_req_ptr, > int **buf_idx_ptr) > { > int *count_my_req_per_proc, count_my_req_procs, *buf_idx; > int i, l, proc; > ADIO_Offset fd_len, rem_len, curr_idx, off; > ADIOI_Access *my_req; > > > *count_my_req_per_proc_ptr = (int *) ADIOI_Calloc(nprocs,sizeof(int)); > count_my_req_per_proc = *count_my_req_per_proc_ptr; > /* count_my_req_per_proc[i] gives the no. of contig. requests of this > process in process i's file domain. calloc initializes to zero. > I'm allocating memory of size nprocs, so that I can do an > MPI_Alltoall later on.*/ > > buf_idx = (int *) ADIOI_Malloc(nprocs*sizeof(int)); > /* buf_idx is relevant only if buftype_is_contig. > buf_idx[i] gives the index into user_buf where data received > from proc. i should be placed. This allows receives to be done > without extra buffer. This can't be done if buftype is not contig. */ > > /* initialize buf_idx to -1 */ > for (i=0; i < nprocs; i++) buf_idx[i] = -1; > > /* one pass just to calculate how much space to allocate for my_req; > * contig_access_count was calculated way back in ADIOI_Calc_my_off_len() > */ > for (i=0; i < contig_access_count; i++) { > > /* When there is no data being processed, bypass this loop */ > if (len_list[i] == 0) continue; > > off = offset_list[i]; > fd_len = len_list[i]; > /* note: we set fd_len to be the total size of the access. then > * ADIOI_Calc_aggregator() will modify the value to return the > * amount that was available from the file domain that holds the > * first part of the access. > */ > proc = ADIOI_BGL_Calc_aggregator(fd, off, min_st_offset, &fd_len, fd_size, > fd_start, fd_end); > count_my_req_per_proc[proc]++; > > /* figure out how much data is remaining in the access (i.e. wasn't > * part of the file domain that had the starting byte); we'll take > * care of this data (if there is any) in the while loop below. > */ > rem_len = len_list[i] - fd_len; > > while (rem_len > 0) { > off += fd_len; /* point to first remaining byte */ > fd_len = rem_len; /* save remaining size, pass to calc */ > proc = ADIOI_BGL_Calc_aggregator(fd, off, min_st_offset, &fd_len, > fd_size, fd_start, fd_end); > > count_my_req_per_proc[proc]++; > rem_len -= fd_len; /* reduce remaining length by amount from fd */ > } > } > > /* now allocate space for my_req, offset, and len */ > > *my_req_ptr = (ADIOI_Access *) > ADIOI_Malloc(nprocs*sizeof(ADIOI_Access)); > my_req = *my_req_ptr; > > count_my_req_procs = 0; > for (i=0; i < nprocs; i++) { > if (count_my_req_per_proc[i]) { > my_req[i].offsets = (ADIO_Offset *) > ADIOI_Malloc(count_my_req_per_proc[i] * sizeof(ADIO_Offset)); > my_req[i].lens = (int *) > ADIOI_Malloc(count_my_req_per_proc[i] * sizeof(int)); > count_my_req_procs++; > } > my_req[i].count = 0; /* will be incremented where needed > later */ > } > > /* now fill in my_req */ > curr_idx = 0; > for (i=0; i > /* When there is no data being processed, bypass this loop */ > if (len_list[i] == 0) continue; > > off = offset_list[i]; > fd_len = len_list[i]; > proc = ADIOI_BGL_Calc_aggregator(fd, off, min_st_offset, &fd_len, fd_size, > fd_start, fd_end); > > /* for each separate contiguous access from this process */ > if (buf_idx[proc] == -1) buf_idx[proc] = (int) curr_idx; > > l = my_req[proc].count; > curr_idx += (int) fd_len; /* NOTE: Why is curr_idx an int? Fix? */ > > rem_len = len_list[i] - fd_len; > > /* store the proc, offset, and len information in an array > * of structures, my_req. Each structure contains the > * offsets and lengths located in that process's FD, > * and the associated count. > */ > my_req[proc].offsets[l] = off; > my_req[proc].lens[l] = (int) fd_len; > my_req[proc].count++; > > while (rem_len > 0) { > off += fd_len; > fd_len = rem_len; > proc = ADIOI_BGL_Calc_aggregator(fd, off, min_st_offset, &fd_len, > fd_size, fd_start, fd_end); > > if (buf_idx[proc] == -1) buf_idx[proc] = (int) curr_idx; > > l = my_req[proc].count; > curr_idx += fd_len; > rem_len -= fd_len; > > my_req[proc].offsets[l] = off; > my_req[proc].lens[l] = (int) fd_len; > my_req[proc].count++; > } > } > > #ifdef AGG_DEBUG > for (i=0; i if (count_my_req_per_proc[i] > 0) { > FPRINTF(stdout, "data needed from %d (count = %d):\n", i, > my_req[i].count); > for (l=0; l < my_req[i].count; l++) { > FPRINTF(stdout, " off[%d] = %Ld, len[%d] = %d\n", l, > my_req[i].offsets[l], l, my_req[i].lens[l]); > } > } > } > #if 0 > for (i=0; i FPRINTF(stdout, "buf_idx[%d] = 0x%x\n", i, buf_idx[i]); > } > #endif > #endif > > *count_my_req_procs_ptr = count_my_req_procs; > *buf_idx_ptr = buf_idx; > } > > /* > * ADIOI_Calc_others_req > * > * param[in] count_my_req_procs Number of processes whose file domain my > * request touches. > * param[in] count_my_req_per_proc count_my_req_per_proc[i] gives the no. of > * contig. requests of this process in > * process i's file domain. > * param[in] my_req A structure defining my request > * param[in] nprocs Number of nodes in the block > * param[in] myrank Rank of this node > * param[out] count_others_req_proc_ptr Number of processes whose requests lie in > * my process's file domain (including my > * process itself) > * param[out] others_req_ptr Array of other process' requests that lie > * in my process's file domain > */ > void ADIOI_BGL_Calc_others_req(ADIO_File fd, int count_my_req_procs, > int *count_my_req_per_proc, > ADIOI_Access *my_req, > int nprocs, int myrank, > int *count_others_req_procs_ptr, > ADIOI_Access **others_req_ptr) > { > /* determine what requests of other processes lie in this process's > file domain */ > > /* count_others_req_procs = number of processes whose requests lie in > this process's file domain (including this process itself) > count_others_req_per_proc[i] indicates how many separate contiguous > requests of proc. i lie in this process's file domain. */ > > int *count_others_req_per_proc, count_others_req_procs; > int i; > ADIOI_Access *others_req; > > /* Parameters for MPI_Alltoallv */ > int *scounts, *sdispls, *rcounts, *rdispls; > > /* Parameters for MPI_Alltoallv. These are the buffers, which > * are later computed to be the lowest address of all buffers > * to be sent/received for offsets and lengths. Initialize to > * the highest possible address which is the current minimum. > */ > void *sendBufForOffsets=(void*)0xFFFFFFFF, > *sendBufForLens =(void*)0xFFFFFFFF, > *recvBufForOffsets=(void*)0xFFFFFFFF, > *recvBufForLens =(void*)0xFFFFFFFF; > > /* first find out how much to send/recv and from/to whom */ > > /* Send 1 int to each process. count_my_req_per_proc[i] is the number of > * requests that my process will do to the file domain owned by process[i]. > * Receive 1 int from each process. count_others_req_per_proc[i] is the number of > * requests that process[i] will do to the file domain owned by my process. > */ > count_others_req_per_proc = (int *) ADIOI_Malloc(nprocs*sizeof(int)); > /* cora2a1=timebase(); */ > MPI_Alltoall(count_my_req_per_proc, 1, MPI_INT, > count_others_req_per_proc, 1, MPI_INT, fd->comm); > /* total_cora2a+=timebase()-cora2a1; */ > > /* Allocate storage for an array of other nodes' accesses of our > * node's file domain. Also allocate storage for the alltoallv > * parameters. > */ > *others_req_ptr = (ADIOI_Access *) > ADIOI_Malloc(nprocs*sizeof(ADIOI_Access)); > others_req = *others_req_ptr; > > scounts = ADIOI_Malloc(nprocs*sizeof(int)); > sdispls = ADIOI_Malloc(nprocs*sizeof(int)); > rcounts = ADIOI_Malloc(nprocs*sizeof(int)); > rdispls = ADIOI_Malloc(nprocs*sizeof(int)); > > /* If process[i] has any requests in my file domain, > * initialize an ADIOI_Access structure that will describe each request > * from process[i]. The offsets, lengths, and buffer pointers still need > * to be obtained to complete the setting of this structure. > */ > count_others_req_procs = 0; > for (i=0; i if (count_others_req_per_proc[i]) { > others_req[i].count = count_others_req_per_proc[i]; > > others_req[i].offsets = (ADIO_Offset *) > ADIOI_Malloc(count_others_req_per_proc[i]*sizeof(ADIO_Offset)); > others_req[i].lens = (int *) > ADIOI_Malloc(count_others_req_per_proc[i]*sizeof(int)); > > if ( (unsigned)others_req[i].offsets < (unsigned)recvBufForOffsets ) > recvBufForOffsets = others_req[i].offsets; > if ( (unsigned)others_req[i].lens < (unsigned)recvBufForLens ) > recvBufForLens = others_req[i].lens; > > others_req[i].mem_ptrs = (MPI_Aint *) > ADIOI_Malloc(count_others_req_per_proc[i]*sizeof(MPI_Aint)); > > count_others_req_procs++; > } > else > { > others_req[i].count = 0; > others_req[i].offsets = NULL; > others_req[i].lens = NULL; > } > } > > /* Now send the calculated offsets and lengths to respective processes */ > > /************************/ > /* Exchange the offsets */ > /************************/ > > /* Determine the lowest sendBufForOffsets/Lens */ > for (i=0; i { > if ( (my_req[i].count) && > ((unsigned)my_req[i].offsets <= (unsigned)sendBufForOffsets) ) > sendBufForOffsets = my_req[i].offsets; > > if ( (my_req[i].count) && > ((unsigned)my_req[i].lens <= (unsigned)sendBufForLens) ) > sendBufForLens = my_req[i].lens; > } > > /* Calculate the displacements from the sendBufForOffsets/Lens */ > for (i=0; i { > // Send these offsets to process i. > scounts[i] = count_my_req_per_proc[i]; > if ( scounts[i] == 0 ) > sdispls[i] = 0; > else > sdispls[i] = ( (unsigned)my_req[i].offsets - > (unsigned)sendBufForOffsets ) / sizeof(ADIO_Offset); > > // Receive these offsets from process i. > rcounts[i] = count_others_req_per_proc[i]; > if ( rcounts[i] == 0 ) > rdispls[i] = 0; > else > rdispls[i] = ( (unsigned)others_req[i].offsets - > (unsigned)recvBufForOffsets ) / sizeof(ADIO_Offset); > } > > /* Exchange the offsets */ > MPI_Alltoallv(sendBufForOffsets, > scounts, sdispls, ADIO_OFFSET, > recvBufForOffsets, > rcounts, rdispls, ADIO_OFFSET, > fd->comm); > > /************************/ > /* Exchange the lengths */ > /************************/ > > for (i=0; i { > // Send these lengths to process i. > scounts[i] = count_my_req_per_proc[i]; > if ( scounts[i] == 0 ) > sdispls[i] = 0; > else > sdispls[i] = ( (unsigned)my_req[i].lens - > (unsigned)sendBufForLens ) / sizeof(int); > > // Receive these offsets from process i. > rcounts[i] = count_others_req_per_proc[i]; > if ( rcounts[i] == 0 ) > rdispls[i] = 0; > else > rdispls[i] = ( (unsigned)others_req[i].lens - > (unsigned)recvBufForLens ) / sizeof(int); > } > > /* Exchange the lengths */ > MPI_Alltoallv(sendBufForLens, > scounts, sdispls, MPI_INT, > recvBufForLens, > rcounts, rdispls, MPI_INT, > fd->comm); > > /* Clean up */ > ADIOI_Free(count_others_req_per_proc); > ADIOI_Free (scounts); > ADIOI_Free (sdispls); > ADIOI_Free (rcounts); > ADIOI_Free (rdispls); > > *count_others_req_procs_ptr = count_others_req_procs; > } diff -rN mpich2-1.0.7rc1/src/mpi/romio/adio/ad_bgl/ad_bgl_aggrs.h bgp-mpich2/src/mpi/romio/adio/ad_bgl/ad_bgl_aggrs.h 0a1,104 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file ad_bgl_aggrs.h > * \brief ??? > */ > > /* > * File: ad_bgl_aggrs.h > * > * Declares functions specific for BG/L - GPFS parallel I/O solution. The implemented optimizations are: > * . Aligned file-domain partitioning, integrated in 7/28/2005 > * > * In addition, following optimizations are planned: > * . Integrating multiple file-domain partitioning schemes > * (corresponding to Alok Chouhdary's persistent file domain work). > */ > > #ifndef AD_BGL_AGGRS_H_ > #define AD_BGL_AGGRS_H_ > > #include "adio.h" > #include > > extern int *aggrsInPset; /* defined in ad_bgl_aggrs.c */ > > > /* File system (BGL) specific information - > hung off of ADIOI_FileD file descriptor (fd->fs_ptr) at open */ > typedef struct ADIOI_BGL_fs_s { > __blksize_t blksize; > } ADIOI_BGL_fs; > > /* generate a list of I/O aggregators that utilizes BGL-PSET orginization. */ > int ADIOI_BGL_gen_agg_ranklist(ADIO_File fd, int n_aggrs_per_pset); > > /* overriding ADIOI_Calc_file_domains() to apply 'aligned file domain partitioning'. */ > void ADIOI_BGL_GPFS_Calc_file_domains(ADIO_Offset *st_offsets, > ADIO_Offset *end_offsets, > int nprocs, > int nprocs_for_coll, > ADIO_Offset *min_st_offset_ptr, > ADIO_Offset **fd_start_ptr, > ADIO_Offset **fd_end_ptr, > ADIO_Offset *fd_size_ptr, > void *fs_ptr); > > /* a utilitiy function for debugging */ > int ADIOI_BGL_Aggrs_index(ADIO_File fd, int myrank ); > > /* overriding ADIOI_Calc_aggregator() for the default implementation is specific for > static file domain partitioning */ > int ADIOI_BGL_Calc_aggregator(ADIO_File fd, > ADIO_Offset off, > ADIO_Offset min_off, > ADIO_Offset *len, > ADIO_Offset fd_size, > ADIO_Offset *fd_start, > ADIO_Offset *fd_end); > > /* overriding ADIOI_Calc_my_req for the default implementation is specific for > static file domain partitioning */ > void ADIOI_BGL_Calc_my_req ( ADIO_File fd, ADIO_Offset *offset_list, int *len_list, > int contig_access_count, ADIO_Offset > min_st_offset, ADIO_Offset *fd_start, > ADIO_Offset *fd_end, ADIO_Offset fd_size, > int nprocs, > int *count_my_req_procs_ptr, > int **count_my_req_per_proc_ptr, > ADIOI_Access **my_req_ptr, > int **buf_idx_ptr); > > /* > * ADIOI_Calc_others_req > * > * param[in] count_my_req_procs Number of processes whose file domain my > * request touches. > * param[in] count_my_req_per_proc count_my_req_per_proc[i] gives the no. of > * contig. requests of this process in > * process i's file domain. > * param[in] my_req A structure defining my request > * param[in] nprocs Number of nodes in the block > * param[in] myrank Rank of this node > * param[out] count_others_req_proc_ptr Number of processes whose requests lie in > * my process's file domain (including my > * process itself) > * param[out] others_req_ptr Array of other process' requests that lie > * in my process's file domain > */ > void ADIOI_BGL_Calc_others_req(ADIO_File fd, int count_my_req_procs, > int *count_my_req_per_proc, > ADIOI_Access *my_req, > int nprocs, int myrank, > int *count_others_req_procs_ptr, > ADIOI_Access **others_req_ptr); > > > #endif /* AD_BGL_AGGRS_H_ */ diff -rN mpich2-1.0.7rc1/src/mpi/romio/adio/ad_bgl/ad_bgl.c bgp-mpich2/src/mpi/romio/adio/ad_bgl/ad_bgl.c 0a1,63 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file ad_bgl.c > * \brief ??? > */ > > /* -*- Mode: C; c-basic-offset:4 ; -*- */ > /* > * Copyright (C) 2001 University of Chicago. > * See COPYRIGHT notice in top-level directory. > */ > > #include "ad_bgl.h" > > /* adioi.h has the ADIOI_Fns_struct define */ > #include "adioi.h" > > struct ADIOI_Fns_struct ADIO_BGL_operations = { > ADIOI_BGL_Open, /* Open */ > ADIOI_BGL_ReadContig, /* ReadContig */ > ADIOI_BGL_WriteContig, /* WriteContig */ > #if BGL_OPTIM_STEP1_2 > ADIOI_BGL_ReadStridedColl, /* ReadStridedColl */ > ADIOI_BGL_WriteStridedColl, /* WriteStridedColl */ > #else > ADIOI_GEN_ReadStridedColl, /* ReadStridedColl */ > ADIOI_GEN_WriteStridedColl, /* WriteStridedColl */ > #endif > ADIOI_GEN_SeekIndividual, /* SeekIndividual */ > ADIOI_BGL_Fcntl, /* Fcntl */ > #if BGL_OPTIM_STEP1_1 > ADIOI_BGL_SetInfo, /* SetInfo */ > #else > ADIOI_GEN_SetInfo, /* SetInfo */ > #endif > ADIOI_BGL_ReadStrided, /* ReadStrided */ > ADIOI_BGL_WriteStrided, /* WriteStrided */ > ADIOI_BGL_Close, /* Close */ > #ifdef ROMIO_HAVE_WORKING_AIO > #warning Consider BG support for NFS before enabling this. > ADIOI_GEN_IreadContig, /* IreadContig */ > ADIOI_GEN_IwriteContig, /* IwriteContig */ > #else > ADIOI_FAKE_IreadContig, /* IreadContig */ > ADIOI_FAKE_IwriteContig, /* IwriteContig */ > #endif > ADIOI_GEN_IODone, /* ReadDone */ > ADIOI_GEN_IODone, /* WriteDone */ > ADIOI_GEN_IOComplete, /* ReadComplete */ > ADIOI_GEN_IOComplete, /* WriteComplete */ > ADIOI_GEN_IreadStrided, /* IreadStrided */ > ADIOI_GEN_IwriteStrided, /* IwriteStrided */ > ADIOI_GEN_Flush, /* Flush */ > ADIOI_GEN_Resize, /* Resize */ > ADIOI_GEN_Delete, /* Delete */ > }; diff -rN mpich2-1.0.7rc1/src/mpi/romio/adio/ad_bgl/ad_bgl_close.c bgp-mpich2/src/mpi/romio/adio/ad_bgl/ad_bgl_close.c 0a1,56 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file ad_bgl_open.c > * \brief ??? > */ > > /* -*- Mode: C; c-basic-offset:4 ; -*- */ > /* > * Copyright (C) 1997 University of Chicago. > * See COPYRIGHT notice in top-level directory. > */ > > #include "ad_bgl.h" > #include "ad_bgl_aggrs.h" > > void ADIOI_BGL_Close(ADIO_File fd, int *error_code) > { > int err, derr=0; > static char myname[] = "ADIOI_BGL_CLOSE"; > > #ifdef PROFILE > MPE_Log_event(9, 0, "start close"); > #endif > > err = close(fd->fd_sys); > if (fd->fd_direct >= 0) > { > derr = close(fd->fd_direct); > } > > #ifdef PROFILE > MPE_Log_event(10, 0, "end close"); > #endif > > /* FPRINTF(stderr,"%s(%d):'%s'. Free %#X\n",myname,__LINE__,fd->filename,(int)fd->fs_ptr);*/ > ADIOI_Free(fd->fs_ptr); > fd->fs_ptr = NULL; > fd->fd_sys = -1; > fd->fd_direct = -1; > > if (err == -1 || derr == -1) > { > *error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, > myname, __LINE__, MPI_ERR_IO, > "**io", > "**io %s", strerror(errno)); > } > else *error_code = MPI_SUCCESS; > } diff -rN mpich2-1.0.7rc1/src/mpi/romio/adio/ad_bgl/ad_bgl_fcntl.c bgp-mpich2/src/mpi/romio/adio/ad_bgl/ad_bgl_fcntl.c 0a1,63 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file ad_bgl_fcntl.c > * \brief ??? > */ > > /* -*- Mode: C; c-basic-offset:4 ; -*- */ > /* > * Copyright (C) 1997 University of Chicago. > * See COPYRIGHT notice in top-level directory. > */ > > #include "ad_bgl.h" > #include "adio_extern.h" > /* #ifdef MPISGI > #include "mpisgi2.h" > #endif */ > > void ADIOI_BGL_Fcntl(ADIO_File fd, int flag, ADIO_Fcntl_t *fcntl_struct, > int *error_code) > { > static char myname[] = "ADIOI_BGL_FCNTL"; > > switch(flag) { > case ADIO_FCNTL_GET_FSIZE: > fcntl_struct->fsize = lseek(fd->fd_sys, 0, SEEK_END); > if (fd->fp_sys_posn != -1) > lseek(fd->fd_sys, fd->fp_sys_posn, SEEK_SET); > if (fcntl_struct->fsize == -1) { > *error_code = MPIO_Err_create_code(MPI_SUCCESS, > MPIR_ERR_RECOVERABLE, myname, > __LINE__, MPI_ERR_IO, "**io", > "**io %s", strerror(errno)); > } > else *error_code = MPI_SUCCESS; > break; > > case ADIO_FCNTL_SET_DISKSPACE: > ADIOI_GEN_Prealloc(fd, fcntl_struct->diskspace, error_code); > break; > > case ADIO_FCNTL_SET_ATOMICITY: > fd->atomicity = (fcntl_struct->atomicity == 0) ? 0 : 1; > *error_code = MPI_SUCCESS; > break; > > /* --BEGIN ERROR HANDLING-- */ > default: > *error_code = MPIO_Err_create_code(MPI_SUCCESS, > MPIR_ERR_RECOVERABLE, > myname, __LINE__, > MPI_ERR_ARG, > "**flag", "**flag %d", flag); > /* --END ERROR HANDLING-- */ > } > } diff -rN mpich2-1.0.7rc1/src/mpi/romio/adio/ad_bgl/ad_bgl_getsh.c bgp-mpich2/src/mpi/romio/adio/ad_bgl/ad_bgl_getsh.c 0a1,89 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file ad_bgl_getsh.c > * \brief ??? > */ > > /* -*- Mode: C; c-basic-offset:4 ; -*- */ > /* > * Copyright (C) 1997 University of Chicago. > * See COPYRIGHT notice in top-level directory. > */ > > #include "ad_bgl.h" > > /* returns the current location of the shared_fp in terms of the > no. of etypes relative to the current view, and also increments the > shared_fp by the number of etypes to be accessed (incr) in the read > or write following this function. */ > > void ADIOI_BGL_Get_shared_fp(ADIO_File fd, int incr, ADIO_Offset *shared_fp, > int *error_code) > { > ADIO_Offset new_fp; > int err; > MPI_Comm dupcommself; > static char myname[] = "ADIOI_BGL_GET_SHARED_FP"; > > if (fd->shared_fp_fd == ADIO_FILE_NULL) { > MPI_Comm_dup(MPI_COMM_SELF, &dupcommself); > fd->shared_fp_fd = ADIO_Open(MPI_COMM_SELF, > dupcommself, > fd->shared_fp_fname, > fd->file_system, > fd->fns, > ADIO_CREATE | ADIO_RDWR | ADIO_DELETE_ON_CLOSE, > 0, > MPI_BYTE, > MPI_BYTE, > MPI_INFO_NULL, > ADIO_PERM_NULL, > error_code); > if (*error_code != MPI_SUCCESS) return; > *shared_fp = 0; > ADIOI_WRITE_LOCK(fd->shared_fp_fd, 0, SEEK_SET, sizeof(ADIO_Offset)); > err = read(fd->shared_fp_fd->fd_sys, shared_fp, sizeof(ADIO_Offset)); > /* if the file is empty, the above read may return error > (reading beyond end of file). In that case, shared_fp = 0, > set above, is the correct value. */ > } > else { > ADIOI_WRITE_LOCK(fd->shared_fp_fd, 0, SEEK_SET, sizeof(ADIO_Offset)); > > err = lseek(fd->shared_fp_fd->fd_sys, 0, SEEK_SET); > if (err == 0) { > err = read(fd->shared_fp_fd->fd_sys, shared_fp, > sizeof(ADIO_Offset)); > } > if (err == -1) { > ADIOI_UNLOCK(fd->shared_fp_fd, 0, SEEK_SET, sizeof(ADIO_Offset)); > *error_code = MPIO_Err_create_code(MPI_SUCCESS, > MPIR_ERR_RECOVERABLE, myname, > __LINE__, MPI_ERR_IO, "**io", > "**io %s", strerror(errno)); > return; > } > } > > new_fp = *shared_fp + incr; > > err = lseek(fd->shared_fp_fd->fd_sys, 0, SEEK_SET); > if (err == 0) { > err = write(fd->shared_fp_fd->fd_sys, &new_fp, sizeof(ADIO_Offset)); > } > ADIOI_UNLOCK(fd->shared_fp_fd, 0, SEEK_SET, sizeof(ADIO_Offset)); > if (err == -1) { > *error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, > myname, __LINE__, MPI_ERR_IO, > "**io", > "**io %s", strerror(errno)); > } > else *error_code = MPI_SUCCESS; > } diff -rN mpich2-1.0.7rc1/src/mpi/romio/adio/ad_bgl/ad_bgl.h bgp-mpich2/src/mpi/romio/adio/ad_bgl/ad_bgl.h 0a1,99 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file ad_bgl.h > * \brief ??? > */ > > /* -*- Mode: C; c-basic-offset:4 ; -*- */ > /* > * Copyright (C) 1997 University of Chicago. > * See COPYRIGHT notice in top-level directory. > */ > > #ifndef AD_BGL_INCLUDE > #define AD_BGL_INCLUDE > > #include > #include > #include > #include > #include "adio.h" > > #ifdef HAVE_SIGNAL_H > #include > #endif > #ifdef HAVE_AIO_H > #include > #endif > > int ADIOI_BGL_aio(ADIO_File fd, void *buf, int len, ADIO_Offset offset, > int wr, void *handle); > > void ADIOI_BGL_Open(ADIO_File fd, int *error_code); > > void ADIOI_BGL_Close(ADIO_File fd, int *error_code); > > void ADIOI_BGL_ReadContig(ADIO_File fd, void *buf, int count, > MPI_Datatype datatype, int file_ptr_type, > ADIO_Offset offset, ADIO_Status *status, int > *error_code); > void ADIOI_BGL_WriteContig(ADIO_File fd, void *buf, int count, > MPI_Datatype datatype, int file_ptr_type, > ADIO_Offset offset, ADIO_Status *status, int > *error_code); > #if 0 > void ADIOI_BGL_IwriteContig(ADIO_File fd, void *buf, int count, > MPI_Datatype datatype, int file_ptr_type, > ADIO_Offset offset, ADIO_Request *request, int > *error_code); > void ADIOI_BGL_IreadContig(ADIO_File fd, void *buf, int count, > MPI_Datatype datatype, int file_ptr_type, > ADIO_Offset offset, ADIO_Request *request, int > *error_code); > int ADIOI_BGL_ReadDone(ADIO_Request *request, ADIO_Status *status, int > *error_code); > int ADIOI_BGL_WriteDone(ADIO_Request *request, ADIO_Status *status, int > *error_code); > void ADIOI_BGL_ReadComplete(ADIO_Request *request, ADIO_Status *status, int > *error_code); > void ADIOI_BGL_WriteComplete(ADIO_Request *request, ADIO_Status *status, > int *error_code); > #endif > void ADIOI_BGL_Fcntl(ADIO_File fd, int flag, ADIO_Fcntl_t *fcntl_struct, int > *error_code); > void ADIOI_BGL_SetInfo(ADIO_File fd, MPI_Info users_info, int *error_code); > > void ADIOI_BGL_WriteStrided(ADIO_File fd, void *buf, int count, > MPI_Datatype datatype, int file_ptr_type, > ADIO_Offset offset, ADIO_Status *status, int > *error_code); > void ADIOI_BGL_ReadStrided(ADIO_File fd, void *buf, int count, > MPI_Datatype datatype, int file_ptr_type, > ADIO_Offset offset, ADIO_Status *status, int > *error_code); > > void ADIOI_BGL_ReadStridedColl(ADIO_File fd, void *buf, int count, > MPI_Datatype datatype, int file_ptr_type, > ADIO_Offset offset, ADIO_Status *status, int > *error_code); > > void ADIOI_BGL_WriteStridedColl(ADIO_File fd, void *buf, int count, > MPI_Datatype datatype, int file_ptr_type, > ADIO_Offset offset, ADIO_Status *status, int > *error_code); > > void ADIOI_BGL_Get_shared_fp(ADIO_File fd, int size, ADIO_Offset *shared_fp, int *error_code); > void ADIOI_BGL_Set_shared_fp(ADIO_File fd, ADIO_Offset offset, int *error_code); > > > #include "ad_bgl_tuning.h" > > > #endif diff -rN mpich2-1.0.7rc1/src/mpi/romio/adio/ad_bgl/ad_bgl_hints.c bgp-mpich2/src/mpi/romio/adio/ad_bgl/ad_bgl_hints.c 0a1,343 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file ad_bgl_hints.c > * \brief ??? > */ > > /* -*- Mode: C; c-basic-offset:4 ; -*- */ > /* > * Copyright (C) 1997 University of Chicago. > * See COPYRIGHT notice in top-level directory. > */ > > #include "adio.h" > #include "adio_extern.h" > > #include "ad_bgl.h" > #include "ad_bgl_pset.h" > #include "ad_bgl_aggrs.h" > > #define ADIOI_BGL_CB_BUFFER_SIZE_DFLT "16777216" > #define ADIOI_BGL_IND_RD_BUFFER_SIZE_DFLT "4194304" > #define ADIOI_BGL_IND_WR_BUFFER_SIZE_DFLT "4194304" > #define ADIOI_BGL_NAGG_IN_PSET_HINT_NAME "bgl_nodes_pset" > > /* Compute the aggregator-related parameters that are required in 2-phase collective IO of ADIO. */ > extern int > ADIOI_BGL_gen_agg_ranklist(ADIO_File fd, int n_proxy_per_pset); > > void ADIOI_BGL_SetInfo(ADIO_File fd, MPI_Info users_info, int *error_code) > { > /* if fd->info is null, create a new info object. > Initialize fd->info to default values. > Initialize fd->hints to default values. > Examine the info object passed by the user. If it contains values that > ROMIO understands, override the default. */ > > MPI_Info info; > char *value; > int flag, intval, tmp_val, nprocs, nprocs_is_valid = 0; > static char myname[] = "ADIOI_GEN_SETINFO"; > > int did_anything = 0; > > if (fd->info == MPI_INFO_NULL) MPI_Info_create(&(fd->info)); > info = fd->info; > > /* Note that fd->hints is allocated at file open time; thus it is > * not necessary to allocate it, or check for allocation, here. > */ > > value = (char *) ADIOI_Malloc((MPI_MAX_INFO_VAL+1)*sizeof(char)); > AD_BGL_assert ((value != NULL)); > > /* initialize info and hints to default values if they haven't been > * previously initialized > */ > if (!fd->hints->initialized) { > > did_anything = 1; > > /* buffer size for collective I/O */ > MPI_Info_set(info, "cb_buffer_size", ADIOI_BGL_CB_BUFFER_SIZE_DFLT); > fd->hints->cb_buffer_size = atoi(ADIOI_BGL_CB_BUFFER_SIZE_DFLT); > > /* default is to let romio automatically decide when to use > * collective buffering > */ > MPI_Info_set(info, "romio_cb_read", "enable"); > fd->hints->cb_read = ADIOI_HINT_ENABLE; > MPI_Info_set(info, "romio_cb_write", "enable"); > fd->hints->cb_write = ADIOI_HINT_ENABLE; > > if ( fd->hints->cb_config_list != NULL ) ADIOI_Free (fd->hints->cb_config_list); > fd->hints->cb_config_list = NULL; > > /* number of processes that perform I/O in collective I/O */ > MPI_Comm_size(fd->comm, &nprocs); > nprocs_is_valid = 1; > sprintf(value, "%d", nprocs); > MPI_Info_set(info, "cb_nodes", value); > fd->hints->cb_nodes = -1; > > /* hint indicating that no indep. I/O will be performed on this file */ > MPI_Info_set(info, "romio_no_indep_rw", "false"); > fd->hints->no_indep_rw = 0; > /* deferred_open derrived from no_indep_rw and cb_{read,write} */ > fd->hints->deferred_open = 0; > > /* buffer size for data sieving in independent reads */ > MPI_Info_set(info, "ind_rd_buffer_size", ADIOI_BGL_IND_RD_BUFFER_SIZE_DFLT); > fd->hints->ind_rd_buffer_size = atoi(ADIOI_BGL_IND_RD_BUFFER_SIZE_DFLT); > > /* buffer size for data sieving in independent writes */ > MPI_Info_set(info, "ind_wr_buffer_size", ADIOI_BGL_IND_WR_BUFFER_SIZE_DFLT); > fd->hints->ind_wr_buffer_size = atoi(ADIOI_BGL_IND_WR_BUFFER_SIZE_DFLT); > > if(fd->file_system == ADIO_UFS) > { > /* default for ufs/pvfs is to disable data sieving */ > MPI_Info_set(info, "romio_ds_read", "disable"); > fd->hints->ds_read = ADIOI_HINT_DISABLE; > MPI_Info_set(info, "romio_ds_write", "disable"); > fd->hints->ds_write = ADIOI_HINT_DISABLE; > } > else > { > /* default is to let romio automatically decide when to use data > * sieving > */ > MPI_Info_set(info, "romio_ds_read", "automatic"); > fd->hints->ds_read = ADIOI_HINT_AUTO; > MPI_Info_set(info, "romio_ds_write", "automatic"); > fd->hints->ds_write = ADIOI_HINT_AUTO; > } > > fd->hints->initialized = 1; > } > > /* add in user's info if supplied */ > if (users_info != MPI_INFO_NULL) { > MPI_Info_get(users_info, "cb_buffer_size", MPI_MAX_INFO_VAL, > value, &flag); > if (flag && ((intval=atoi(value)) > 0)) { > tmp_val = intval; > > MPI_Bcast(&tmp_val, 1, MPI_INT, 0, fd->comm); > /* --BEGIN ERROR HANDLING-- */ > if (tmp_val != intval) { > MPIO_ERR_CREATE_CODE_INFO_NOT_SAME(myname, > "cb_buffer_size", > error_code); > return; > } > /* --END ERROR HANDLING-- */ > > MPI_Info_set(info, "cb_buffer_size", value); > fd->hints->cb_buffer_size = intval; > > } > > /* new hints for enabling/disabling coll. buffering on > * reads/writes > */ > MPI_Info_get(users_info, "romio_cb_read", MPI_MAX_INFO_VAL, value, &flag); > if (flag) { > if (!strcmp(value, "enable") || !strcmp(value, "ENABLE")) { > MPI_Info_set(info, "romio_cb_read", value); > fd->hints->cb_read = ADIOI_HINT_ENABLE; > } > else if (!strcmp(value, "disable") || !strcmp(value, "DISABLE")) { > /* romio_cb_read overrides no_indep_rw */ > MPI_Info_set(info, "romio_cb_read", value); > MPI_Info_set(info, "romio_no_indep_rw", "false"); > fd->hints->cb_read = ADIOI_HINT_DISABLE; > fd->hints->no_indep_rw = ADIOI_HINT_DISABLE; > } > else if (!strcmp(value, "automatic") || !strcmp(value, "AUTOMATIC")) > { > MPI_Info_set(info, "romio_cb_read", value); > fd->hints->cb_read = ADIOI_HINT_AUTO; > } > > tmp_val = fd->hints->cb_read; > > MPI_Bcast(&tmp_val, 1, MPI_INT, 0, fd->comm); > /* --BEGIN ERROR HANDLING-- */ > if (tmp_val != fd->hints->cb_read) { > MPIO_ERR_CREATE_CODE_INFO_NOT_SAME(myname, > "romio_cb_read", > error_code); > return; > } > /* --END ERROR HANDLING-- */ > } > MPI_Info_get(users_info, "romio_cb_write", MPI_MAX_INFO_VAL, value, &flag); > if (flag) { > if (!strcmp(value, "enable") || !strcmp(value, "ENABLE")) { > MPI_Info_set(info, "romio_cb_write", value); > fd->hints->cb_write = ADIOI_HINT_ENABLE; > } > else if (!strcmp(value, "disable") || !strcmp(value, "DISABLE")) > { > /* romio_cb_write overrides no_indep_rw, too */ > MPI_Info_set(info, "romio_cb_write", value); > MPI_Info_set(info, "romio_no_indep_rw", "false"); > fd->hints->cb_write = ADIOI_HINT_DISABLE; > fd->hints->no_indep_rw = ADIOI_HINT_DISABLE; > } > else if (!strcmp(value, "automatic") || > !strcmp(value, "AUTOMATIC")) > { > MPI_Info_set(info, "romio_cb_write", value); > fd->hints->cb_write = ADIOI_HINT_AUTO; > } > > tmp_val = fd->hints->cb_write; > > MPI_Bcast(&tmp_val, 1, MPI_INT, 0, fd->comm); > /* --BEGIN ERROR HANDLING-- */ > if (tmp_val != fd->hints->cb_write) { > MPIO_ERR_CREATE_CODE_INFO_NOT_SAME(myname, > "romio_cb_write", > error_code); > return; > } > /* --END ERROR HANDLING-- */ > } > > /* new hint for specifying no indep. read/write will be performed */ > MPI_Info_get(users_info, "romio_no_indep_rw", MPI_MAX_INFO_VAL, value, &flag); > if (flag) { > if (!strcmp(value, "true") || !strcmp(value, "TRUE")) { > /* if 'no_indep_rw' set, also hint that we will do > * collective buffering: if we aren't doing independent io, > * then we have to do collective */ > MPI_Info_set(info, "romio_no_indep_rw", value); > MPI_Info_set(info, "romio_cb_write", "enable"); > MPI_Info_set(info, "romio_cb_read", "enable"); > fd->hints->no_indep_rw = 1; > fd->hints->cb_read = 1; > fd->hints->cb_write = 1; > tmp_val = 1; > } > else if (!strcmp(value, "false") || !strcmp(value, "FALSE")) { > MPI_Info_set(info, "romio_no_indep_rw", value); > fd->hints->no_indep_rw = 0; > tmp_val = 0; > } > else { > /* default is above */ > tmp_val = 0; > } > > MPI_Bcast(&tmp_val, 1, MPI_INT, 0, fd->comm); > /* --BEGIN ERROR HANDLING-- */ > if (tmp_val != fd->hints->no_indep_rw) { > MPIO_ERR_CREATE_CODE_INFO_NOT_SAME(myname, > "romio_no_indep_rw", > error_code); > return; > } > /* --END ERROR HANDLING-- */ > } > /* new hints for enabling/disabling data sieving on > * reads/writes > */ > MPI_Info_get(users_info, "romio_ds_read", MPI_MAX_INFO_VAL, value, > &flag); > if (flag) { > if (!strcmp(value, "enable") || !strcmp(value, "ENABLE")) { > MPI_Info_set(info, "romio_ds_read", value); > fd->hints->ds_read = ADIOI_HINT_ENABLE; > } > else if (!strcmp(value, "disable") || !strcmp(value, "DISABLE")) { > MPI_Info_set(info, "romio_ds_read", value); > fd->hints->ds_read = ADIOI_HINT_DISABLE; > } > else if (!strcmp(value, "automatic") || !strcmp(value, "AUTOMATIC")) > { > MPI_Info_set(info, "romio_ds_read", value); > fd->hints->ds_read = ADIOI_HINT_AUTO; > } > /* otherwise ignore */ > } > MPI_Info_get(users_info, "romio_ds_write", MPI_MAX_INFO_VAL, value, > &flag); > if (flag) { > if (!strcmp(value, "enable") || !strcmp(value, "ENABLE")) { > MPI_Info_set(info, "romio_ds_write", value); > fd->hints->ds_write = ADIOI_HINT_ENABLE; > } > else if (!strcmp(value, "disable") || !strcmp(value, "DISABLE")) { > MPI_Info_set(info, "romio_ds_write", value); > fd->hints->ds_write = ADIOI_HINT_DISABLE; > } > else if (!strcmp(value, "automatic") || !strcmp(value, "AUTOMATIC")) > { > MPI_Info_set(info, "romio_ds_write", value); > fd->hints->ds_write = ADIOI_HINT_AUTO; > } > /* otherwise ignore */ > } > > MPI_Info_get(users_info, "ind_wr_buffer_size", MPI_MAX_INFO_VAL, > value, &flag); > if (flag && ((intval = atoi(value)) > 0)) { > MPI_Info_set(info, "ind_wr_buffer_size", value); > fd->hints->ind_wr_buffer_size = intval; > } > > MPI_Info_get(users_info, "ind_rd_buffer_size", MPI_MAX_INFO_VAL, > value, &flag); > if (flag && ((intval = atoi(value)) > 0)) { > MPI_Info_set(info, "ind_rd_buffer_size", value); > fd->hints->ind_rd_buffer_size = intval; > } > > memset( value, 0, MPI_MAX_INFO_VAL+1 ); > MPI_Info_get(users_info, ADIOI_BGL_NAGG_IN_PSET_HINT_NAME, MPI_MAX_INFO_VAL, > value, &flag); > if (flag && ((intval = atoi(value)) > 0)) { > > did_anything = 1; > MPI_Info_set(info, ADIOI_BGL_NAGG_IN_PSET_HINT_NAME, value); > fd->hints->cb_nodes = intval; > } > } > > /* associate CB aggregators to certain CNs in every involved PSET */ > if (did_anything) { > ADIOI_BGL_gen_agg_ranklist(fd, fd->hints->cb_nodes); > } > > /* deferred_open won't be set by callers, but if the user doesn't > * explicitly disable collecitve buffering (two-phase) and does hint that > * io w/o independent io is going on, we'll set this internal hint as a > * convenience */ > if ( ( (fd->hints->cb_read != ADIOI_HINT_DISABLE) > && (fd->hints->cb_write != ADIOI_HINT_DISABLE) > && fd->hints->no_indep_rw ) ) > { > fd->hints->deferred_open = 1; > } else { > /* setting romio_no_indep_rw enable and romio_cb_{read,write} > * disable at the same time doesn't make sense. honor > * romio_cb_{read,write} and force the no_indep_rw hint to > * 'disable' */ > MPI_Info_set(info, "romio_no_indep_rw", "false"); > fd->hints->no_indep_rw = 0; > fd->hints->deferred_open = 0; > } > > ADIOI_Free(value); > > *error_code = MPI_SUCCESS; > } diff -rN mpich2-1.0.7rc1/src/mpi/romio/adio/ad_bgl/ad_bgl_open.c bgp-mpich2/src/mpi/romio/adio/ad_bgl/ad_bgl_open.c 0a1,119 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file ad_bgl_open.c > * \brief ??? > */ > > /* -*- Mode: C; c-basic-offset:4 ; -*- */ > /* > * Copyright (C) 1997 University of Chicago. > * See COPYRIGHT notice in top-level directory. > */ > > #include "ad_bgl.h" > #include "ad_bgl_aggrs.h" > > void ADIOI_BGL_Open(ADIO_File fd, int *error_code) > { > int perm, old_mask, amode; > static char myname[] = "ADIOI_BGL_OPEN"; > > /* set internal variables for tuning environment variables */ > ad_bgl_get_env_vars(); > > if (fd->perm == ADIO_PERM_NULL) { > old_mask = umask(022); > umask(old_mask); > perm = old_mask ^ 0666; > } > else perm = fd->perm; > > amode = 0; > if (fd->access_mode & ADIO_CREATE) > amode = amode | O_CREAT; > if (fd->access_mode & ADIO_RDONLY) > amode = amode | O_RDONLY; > if (fd->access_mode & ADIO_WRONLY) > amode = amode | O_WRONLY; > if (fd->access_mode & ADIO_RDWR) > amode = amode | O_RDWR; > if (fd->access_mode & ADIO_EXCL) > amode = amode | O_EXCL; > > fd->fd_sys = open(fd->filename, amode, perm); > fd->fd_direct = -1; > > if ((fd->fd_sys != -1) && (fd->access_mode & ADIO_APPEND)) > fd->fp_ind = fd->fp_sys_posn = lseek(fd->fd_sys, 0, SEEK_END); > > if(fd->fd_sys != -1) > { > struct stat64 bgl_stat; > int rc = stat64(fd->filename,&bgl_stat); > if (rc >= 0) > { > /* store the blksize in the file system specific storage */ > AD_BGL_assert(fd->fs_ptr == NULL); > fd->fs_ptr = (ADIOI_BGL_fs*) ADIOI_Malloc(sizeof(ADIOI_BGL_fs)); > ((ADIOI_BGL_fs*)fd->fs_ptr)->blksize = bgl_stat.st_blksize; > /* FPRINTF(stderr,"%s(%d):Successful stat '%s'. Blocksize=%ld\n",myname,__LINE__,fd->filename,bgl_stat.st_blksize);*/ > } > /* else > FPRINTF(stderr,"%s(%d):Stat '%s' failed with rc=%d, errno=%d\n",myname,__LINE__,fd->filename,rc,errno);*/ > } > > if (fd->fd_sys == -1) { > if (errno == ENAMETOOLONG) > *error_code = MPIO_Err_create_code(MPI_SUCCESS, > MPIR_ERR_RECOVERABLE, myname, > __LINE__, MPI_ERR_BAD_FILE, > "**filenamelong", > "**filenamelong %s %d", > fd->filename, > strlen(fd->filename)); > else if (errno == ENOENT) > *error_code = MPIO_Err_create_code(MPI_SUCCESS, > MPIR_ERR_RECOVERABLE, myname, > __LINE__, MPI_ERR_NO_SUCH_FILE, > "**filenoexist", > "**filenoexist %s", > fd->filename); > else if (errno == ENOTDIR || errno == ELOOP) > *error_code = MPIO_Err_create_code(MPI_SUCCESS, > MPIR_ERR_RECOVERABLE, > myname, __LINE__, > MPI_ERR_BAD_FILE, > "**filenamedir", > "**filenamedir %s", > fd->filename); > else if (errno == EACCES) { > *error_code = MPIO_Err_create_code(MPI_SUCCESS, > MPIR_ERR_RECOVERABLE, myname, > __LINE__, MPI_ERR_ACCESS, > "**fileaccess", > "**fileaccess %s", > fd->filename ); > } > else if (errno == EROFS) { > /* Read only file or file system and write access requested */ > *error_code = MPIO_Err_create_code(MPI_SUCCESS, > MPIR_ERR_RECOVERABLE, myname, > __LINE__, MPI_ERR_READ_ONLY, > "**ioneedrd", 0 ); > } > else { > *error_code = MPIO_Err_create_code(MPI_SUCCESS, > MPIR_ERR_RECOVERABLE, myname, > __LINE__, MPI_ERR_IO, "**io", > "**io %s", strerror(errno)); > } > } > else *error_code = MPI_SUCCESS; > } diff -rN mpich2-1.0.7rc1/src/mpi/romio/adio/ad_bgl/ad_bgl_pset.c bgp-mpich2/src/mpi/romio/adio/ad_bgl/ad_bgl_pset.c 0a1,114 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file ad_bgl_pset.c > * \brief Definition of functions associated to structs ADIOI_BGL_ProcInfo_t and ADIOI_BGL_ConfInfo_t > */ > > /* -*- Mode: C; c-basic-offset:4 ; -*- */ > /* > * Copyright (C) 1997 University of Chicago. > * See COPYRIGHT notice in top-level directory. > */ > > #include > #include "ad_bgl.h" > #include "ad_bgl_pset.h" > #include "mpidimpl.h" > > ADIOI_BGL_ProcInfo_t * > ADIOI_BGL_ProcInfo_new() > { > ADIOI_BGL_ProcInfo_t *p = (ADIOI_BGL_ProcInfo_t *) ADIOI_Malloc (sizeof(ADIOI_BGL_ProcInfo_t)); > AD_BGL_assert ((p != NULL)); > return p; > } > > ADIOI_BGL_ProcInfo_t * > ADIOI_BGL_ProcInfo_new_n( int n ) > { > ADIOI_BGL_ProcInfo_t *p = (ADIOI_BGL_ProcInfo_t *) ADIOI_Malloc (n * sizeof(ADIOI_BGL_ProcInfo_t)); > AD_BGL_assert ((p != NULL)); > return p; > } > > void > ADIOI_BGL_ProcInfo_free( ADIOI_BGL_ProcInfo_t *info ) > { > if (info != NULL) ADIOI_Free (info); > } > > static > void > ADIOI_BGL_ProcInfo_set(ADIOI_BGL_ProcInfo_t *info, const DCMF_Hardware_t *hw, int r) > { > info->psetNum = hw->idOfPset; > info->xInPset = hw->xCoord; > info->yInPset = hw->yCoord; > info->zInPset = hw->zCoord; > info->cpuid = hw->tCoord; > info->rank = r; > info->rankInPset = hw->rankInPset; > } > > > ADIOI_BGL_ConfInfo_t * > ADIOI_BGL_ConfInfo_new () > { > ADIOI_BGL_ConfInfo_t *p = (ADIOI_BGL_ConfInfo_t *) ADIOI_Malloc (sizeof(ADIOI_BGL_ConfInfo_t)); > AD_BGL_assert ((p != NULL)); > return p; > } > > static > void > ADIOI_BGL_ConfInfo_set(ADIOI_BGL_ConfInfo_t *info, const DCMF_Hardware_t *hw, int s, int n_aggrs) > { > info->PsetSize = hw->sizeOfPset; > info->numPsets = (hw->xSize * hw->ySize * > hw->zSize) / hw->sizeOfPset; > info->isVNM = (hw->tSize != 1); > info->cpuidSize = hw->tSize; > info->virtualPsetSize = hw->sizeOfPset * hw->tSize; > info->nProcs = s; > > /* More complicated logic maybe needed for nAggrs specification */ > info->nAggrs = n_aggrs; > if ( info->nAggrs <=0 || MIN(info->nProcs, info->virtualPsetSize) < info->nAggrs ) > info->nAggrs = ADIOI_BGL_NAGG_PSET_DFLT; > if ( info->nAggrs > info->virtualPsetSize ) info->nAggrs = info->virtualPsetSize; > > info->aggRatio = 1. * info->nAggrs / info->virtualPsetSize; > if (info->aggRatio > 1) info->aggRatio = 1.; > } > > void > ADIOI_BGL_ConfInfo_free( ADIOI_BGL_ConfInfo_t *info ) > { > if (info != NULL) ADIOI_Free (info); > } > > void > ADIOI_BGL_persInfo_init(ADIOI_BGL_ConfInfo_t *conf, > ADIOI_BGL_ProcInfo_t *proc, > int s, int r, int n_aggrs) > { > DCMF_Hardware_t hw; > DCMF_Hardware(&hw); > > ADIOI_BGL_ConfInfo_set (conf, &hw, s, n_aggrs); > ADIOI_BGL_ProcInfo_set (proc, &hw, r); > } > > void > ADIOI_BGL_persInfo_free( ADIOI_BGL_ConfInfo_t *conf, ADIOI_BGL_ProcInfo_t *proc ) > { > ADIOI_BGL_ConfInfo_free( conf ); > ADIOI_BGL_ProcInfo_free( proc ); > } diff -rN mpich2-1.0.7rc1/src/mpi/romio/adio/ad_bgl/ad_bgl_pset.h bgp-mpich2/src/mpi/romio/adio/ad_bgl/ad_bgl_pset.h 0a1,85 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file ad_bgl_pset.h > * \brief ??? > */ > > /* File: ad_bgl_pset.h > * > * Defines two structures that keep BG/L PSET specific information and their public interfaces: > * . ADIOI_BGL_ProcInfo_t object keeps specific information to each process > * . ADIOI_BGL_ConfInfo_t object keeps general information for the whole communicator, only kept > * on process 0. > */ > > #ifndef AD_BGL_PSET_H_ > #define AD_BGL_PSET_H_ > > /* Keeps specific information to each process, will be exchanged among processes */ > typedef struct { > > int psetNum; /* which PSET I am in */ > int rank; /* my rank */ > int xInPset; /* my relative coordinates in my PSET */ > int yInPset; > int zInPset; > int cpuid; /* my CPU id -- for virtual node mode (t coord)*/ > int rankInPset; /* my relative rank in my PSET */ > > } ADIOI_BGL_ProcInfo_t __attribute__((aligned(16))); > > > /* Keeps general information for the whole communicator, only on process 0 */ > typedef struct { > > int PsetSize; > int nAggrs; > int numPsets; > int isVNM; > int virtualPsetSize; > int nProcs; > float aggRatio; > int cpuidSize; /* how many cpu ids? (t size) */ > > } ADIOI_BGL_ConfInfo_t __attribute__((aligned(16))); > > > #undef MIN > #define MIN(a,b) ((a > > /* Default is to choose 8 aggregator nodes in each 32 CN pset. > Also defines default ratio of aggregator nodes in each a pset. > For Virtual Node Mode, the ratio is 8/64 */ > #define ADIOI_BGL_NAGG_PSET_MIN 1 > #define ADIOI_BGL_NAGG_PSET_DFLT 8 > #define ADIOI_BGL_PSET_SIZE_DFLT 32 > > > /* public funcs for ADIOI_BGL_ProcInfo_t objects */ > ADIOI_BGL_ProcInfo_t * ADIOI_BGL_ProcInfo_new(); > ADIOI_BGL_ProcInfo_t * ADIOI_BGL_ProcInfo_new_n( int n ); > void ADIOI_BGL_ProcInfo_free( ADIOI_BGL_ProcInfo_t *info ); > > > /* public funcs for ADIOI_BGL_ConfInfo_t objects */ > ADIOI_BGL_ConfInfo_t * ADIOI_BGL_ConfInfo_new (); > void ADIOI_BGL_ConfInfo_free( ADIOI_BGL_ConfInfo_t *info ); > > > /* public funcs for a pair of ADIOI_BGL_ConfInfo_t and ADIOI_BGL_ProcInfo_t objects */ > void ADIOI_BGL_persInfo_init( ADIOI_BGL_ConfInfo_t *conf, > ADIOI_BGL_ProcInfo_t *proc, > int s, int r, int n_aggrs ); > void ADIOI_BGL_persInfo_free( ADIOI_BGL_ConfInfo_t *conf, > ADIOI_BGL_ProcInfo_t *proc ); > > > #endif /* AD_BGL_PSET_H_ */ diff -rN mpich2-1.0.7rc1/src/mpi/romio/adio/ad_bgl/ad_bgl_rdcoll.c bgp-mpich2/src/mpi/romio/adio/ad_bgl/ad_bgl_rdcoll.c 0a1,1314 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file ad_bgl_rdcoll.c > * \brief ??? > */ > > /* -*- Mode: C; c-basic-offset:4 ; -*- */ > /* > * Copyright (C) 1997 University of Chicago. > * See COPYRIGHT notice in top-level directory. > */ > > #include "adio.h" > #include "adio_extern.h" > #include "ad_bgl.h" > #include "ad_bgl_pset.h" > #include "ad_bgl_aggrs.h" > > #ifdef PROFILE > #include "mpe.h" > #endif > > /* prototypes of functions used for collective reads only. */ > static void ADIOI_Read_and_exch(ADIO_File fd, void *buf, MPI_Datatype > datatype, int nprocs, > int myrank, ADIOI_Access > *others_req, ADIO_Offset *offset_list, > int *len_list, int contig_access_count, > ADIO_Offset > min_st_offset, ADIO_Offset fd_size, > ADIO_Offset *fd_start, ADIO_Offset *fd_end, > int *buf_idx, int *error_code); > static void ADIOI_R_Exchange_data(ADIO_File fd, void *buf, ADIOI_Flatlist_node > *flat_buf, ADIO_Offset *offset_list, int > *len_list, int *send_size, int *recv_size, > int *count, int *start_pos, > int *partial_send, > int *recd_from_proc, int nprocs, > int myrank, int > buftype_is_contig, int contig_access_count, > ADIO_Offset min_st_offset, > ADIO_Offset fd_size, > ADIO_Offset *fd_start, ADIO_Offset *fd_end, > ADIOI_Access *others_req, > int iter, > MPI_Aint buftype_extent, int *buf_idx); > static void ADIOI_R_Exchange_data_alltoallv(ADIO_File fd, void *buf, ADIOI_Flatlist_node > *flat_buf, ADIO_Offset *offset_list, int > *len_list, int *send_size, int *recv_size, > int *count, int *start_pos, > int *partial_send, > int *recd_from_proc, int nprocs, > int myrank, int > buftype_is_contig, int contig_access_count, > ADIO_Offset min_st_offset, > ADIO_Offset fd_size, > ADIO_Offset *fd_start, ADIO_Offset *fd_end, > ADIOI_Access *others_req, > int iter, > MPI_Aint buftype_extent, int *buf_idx); > static void ADIOI_Fill_user_buffer(ADIO_File fd, void *buf, ADIOI_Flatlist_node > *flat_buf, char **recv_buf, ADIO_Offset > *offset_list, int *len_list, > int *recv_size, > MPI_Request *requests, MPI_Status *statuses, > int *recd_from_proc, int nprocs, > int contig_access_count, > ADIO_Offset min_st_offset, > ADIO_Offset fd_size, ADIO_Offset *fd_start, > ADIO_Offset *fd_end, > MPI_Aint buftype_extent); > > extern void ADIOI_Calc_my_off_len(ADIO_File fd, int bufcount, MPI_Datatype > datatype, int file_ptr_type, ADIO_Offset > offset, ADIO_Offset **offset_list_ptr, int > **len_list_ptr, ADIO_Offset *start_offset_ptr, > ADIO_Offset *end_offset_ptr, int > *contig_access_count_ptr); > > void ADIOI_BGL_ReadStridedColl(ADIO_File fd, void *buf, int count, > MPI_Datatype datatype, int file_ptr_type, > ADIO_Offset offset, ADIO_Status *status, int > *error_code) > { > /* Uses a generalized version of the extended two-phase method described > in "An Extended Two-Phase Method for Accessing Sections of > Out-of-Core Arrays", Rajeev Thakur and Alok Choudhary, > Scientific Programming, (5)4:301--317, Winter 1996. > http://www.mcs.anl.gov/home/thakur/ext2ph.ps */ > > ADIOI_Access *my_req; > /* array of nprocs structures, one for each other process in > whose file domain this process's request lies */ > > ADIOI_Access *others_req; > /* array of nprocs structures, one for each other process > whose request lies in this process's file domain. */ > > int i, filetype_is_contig, nprocs, nprocs_for_coll, myrank; > int contig_access_count, interleave_count = 0, buftype_is_contig; > int *count_my_req_per_proc, count_my_req_procs, count_others_req_procs; > ADIO_Offset start_offset, end_offset, orig_fp, fd_size, min_st_offset, off; > ADIO_Offset *offset_list = NULL, *st_offsets = NULL, *fd_start = NULL, > *fd_end = NULL, *end_offsets = NULL; > ADIO_Offset *bgl_offsets0 = NULL, *bgl_offsets = NULL; > int ii; > int *len_list = NULL, *buf_idx = NULL; > > double io_time = 0., all_time, max_all_time; > double tstep1, max_tstep1; > double tstep1_1, max_tstep1_1; > double tstep1_2, max_tstep1_2; > double tstep1_3, max_tstep1_3; > double tstep2, max_tstep2; > double tstep3, max_tstep3; > double tstep4, max_tstep4; > double sum_sz; > > #if BGL_PROFILE > BGLMPIO_T_CIO_RESET( 0, r ) > #endif > > #ifdef HAVE_STATUS_SET_BYTES > int bufsize, size; > #endif > > #ifdef PROFILE > MPE_Log_event(13, 0, "start computation"); > #endif > > MPI_Comm_size(fd->comm, &nprocs); > MPI_Comm_rank(fd->comm, &myrank); > > /* number of aggregators, cb_nodes, is stored in the hints */ > nprocs_for_coll = fd->hints->cb_nodes; > orig_fp = fd->fp_ind; > > #if BGL_PROFILE > BGLMPIO_T_CIO_SET_GET( 0, r, 0, 1, 0, BGLMPIO_CIO_LCOMP, BGLMPIO_CIO_LAST ) > #endif > > /* only check for interleaving if cb_read isn't disabled */ > if (fd->hints->cb_read != ADIOI_HINT_DISABLE) { > /* For this process's request, calculate the list of offsets and > lengths in the file and determine the start and end offsets. */ > > /* Note: end_offset points to the last byte-offset that will be accessed. > e.g., if start_offset=0 and 100 bytes to be read, end_offset=99*/ > > ADIOI_Calc_my_off_len(fd, count, datatype, file_ptr_type, offset, > &offset_list, &len_list, &start_offset, > &end_offset, &contig_access_count); > > #if BGL_PROFILE > BGLMPIO_T_CIO_SET_GET( 0, r, 1, 1, 1, BGLMPIO_CIO_GATHER, BGLMPIO_CIO_LCOMP ) > #endif > > /* for (i=0; i FPRINTF(stderr, "rank %d off %ld len %d\n", myrank, offset_list[i], > len_list[i]); > }*/ > > /* each process communicates its start and end offsets to other > processes. The result is an array each of start and end offsets stored > in order of process rank. */ > > st_offsets = (ADIO_Offset *) ADIOI_Malloc(nprocs*sizeof(ADIO_Offset)); > end_offsets = (ADIO_Offset *) ADIOI_Malloc(nprocs*sizeof(ADIO_Offset)); > > if (bglmpio_tunegather) { > bgl_offsets0 = (ADIO_Offset *) ADIOI_Malloc(2*nprocs*sizeof(ADIO_Offset)); > bgl_offsets = (ADIO_Offset *) ADIOI_Malloc(2*nprocs*sizeof(ADIO_Offset)); > for (ii=0; ii bgl_offsets0[ii*2] = 0; > bgl_offsets0[ii*2+1] = 0; > } > bgl_offsets0[myrank*2] = start_offset; > bgl_offsets0[myrank*2+1] = end_offset; > > MPI_Allreduce( bgl_offsets0, bgl_offsets, nprocs*2, ADIO_OFFSET, MPI_MAX, fd->comm ); > > for (ii=0; ii st_offsets [ii] = bgl_offsets[ii*2] ; > end_offsets[ii] = bgl_offsets[ii*2+1]; > } > ADIOI_Free( bgl_offsets0 ); > ADIOI_Free( bgl_offsets ); > } else { > MPI_Allgather(&start_offset, 1, ADIO_OFFSET, st_offsets, 1, > ADIO_OFFSET, fd->comm); > MPI_Allgather(&end_offset, 1, ADIO_OFFSET, end_offsets, 1, > ADIO_OFFSET, fd->comm); > } > > #if BGL_PROFILE > BGLMPIO_T_CIO_SET_GET( 0, r, 0, 1, 1, BGLMPIO_CIO_PATANA, BGLMPIO_CIO_GATHER ) > #endif > > /* are the accesses of different processes interleaved? */ > for (i=1; i if (st_offsets[i] < end_offsets[i-1]) interleave_count++; > /* This is a rudimentary check for interleaving, but should suffice > for the moment. */ > } > > ADIOI_Datatype_iscontig(datatype, &buftype_is_contig); > > if (fd->hints->cb_read == ADIOI_HINT_DISABLE > || (!interleave_count && (fd->hints->cb_read == ADIOI_HINT_AUTO))) > { > /* don't do aggregation */ > if (fd->hints->cb_read != ADIOI_HINT_DISABLE) { > ADIOI_Free(offset_list); > ADIOI_Free(len_list); > ADIOI_Free(st_offsets); > ADIOI_Free(end_offsets); > } > > fd->fp_ind = orig_fp; > ADIOI_Datatype_iscontig(fd->filetype, &filetype_is_contig); > > if (buftype_is_contig && filetype_is_contig) { > if (file_ptr_type == ADIO_EXPLICIT_OFFSET) { > off = fd->disp + (fd->etype_size) * offset; > ADIO_ReadContig(fd, buf, count, datatype, ADIO_EXPLICIT_OFFSET, > off, status, error_code); > } > else ADIO_ReadContig(fd, buf, count, datatype, ADIO_INDIVIDUAL, > 0, status, error_code); > } > else ADIO_ReadStrided(fd, buf, count, datatype, file_ptr_type, > offset, status, error_code); > > return; > } > > #if BGL_PROFILE > BGLMPIO_T_CIO_SET_GET( 0, r, 1, 1, 1, BGLMPIO_CIO_FD_PART, BGLMPIO_CIO_PATANA ) > #endif > > /* We're going to perform aggregation of I/O. Here we call > * ADIOI_Calc_file_domains() to determine what processes will handle I/O > * to what regions. We pass nprocs_for_coll into this function; it is > * used to determine how many processes will perform I/O, which is also > * the number of regions into which the range of bytes must be divided. > * These regions are called "file domains", or FDs. > * > * When this function returns, fd_start, fd_end, fd_size, and > * min_st_offset will be filled in. fd_start holds the starting byte > * location for each file domain. fd_end holds the ending byte location. > * min_st_offset holds the minimum byte location that will be accessed. > * > * Both fd_start[] and fd_end[] are indexed by an aggregator number; this > * needs to be mapped to an actual rank in the communicator later. > * > */ > if (bglmpio_tuneblocking) > ADIOI_BGL_GPFS_Calc_file_domains(st_offsets, end_offsets, nprocs, > nprocs_for_coll, &min_st_offset, > &fd_start, &fd_end, &fd_size, fd->fs_ptr); > else > ADIOI_Calc_file_domains(st_offsets, end_offsets, nprocs, > nprocs_for_coll, &min_st_offset, > &fd_start, &fd_end, &fd_size); > > #if BGL_PROFILE > BGLMPIO_T_CIO_SET_GET( 0, r, 0, 1, 1, BGLMPIO_CIO_MYREQ, BGLMPIO_CIO_FD_PART ) > #endif > > /* calculate where the portions of the access requests of this process > * are located in terms of the file domains. this could be on the same > * process or on other processes. this function fills in: > * count_my_req_procs - number of processes (including this one) for which > * this process has requests in their file domain > * count_my_req_per_proc - count of requests for each process, indexed > * by rank of the process > * my_req[] - array of data structures describing the requests to be > * performed by each process (including self). indexed by rank. > * buf_idx[] - array of locations into which data can be directly moved; > * this is only valid for contiguous buffer case > */ > if (bglmpio_tuneblocking) > ADIOI_BGL_Calc_my_req(fd, offset_list, len_list, contig_access_count, > min_st_offset, fd_start, fd_end, fd_size, > nprocs, &count_my_req_procs, > &count_my_req_per_proc, &my_req, > &buf_idx); > else > ADIOI_Calc_my_req(fd, offset_list, len_list, contig_access_count, > min_st_offset, fd_start, fd_end, fd_size, > nprocs, &count_my_req_procs, > &count_my_req_per_proc, &my_req, > &buf_idx); > > #if BGL_PROFILE > BGLMPIO_T_CIO_SET_GET( 0, r, 1, 1, 1, BGLMPIO_CIO_OTHREQ, BGLMPIO_CIO_MYREQ ) > #endif > > /* perform a collective communication in order to distribute the > * data calculated above. fills in the following: > * count_others_req_procs - number of processes (including this > * one) which have requests in this process's file domain. > * count_others_req_per_proc[] - number of separate contiguous > * requests from proc i lie in this process's file domain. > */ > if (bglmpio_tuneblocking) > ADIOI_BGL_Calc_others_req(fd, count_my_req_procs, > count_my_req_per_proc, my_req, > nprocs, myrank, &count_others_req_procs, > &others_req); > > else > ADIOI_Calc_others_req(fd, count_my_req_procs, > count_my_req_per_proc, my_req, > nprocs, myrank, &count_others_req_procs, > &others_req); > > #if BGL_PROFILE > BGLMPIO_T_CIO_SET_GET( 0, r, 1, 1, 1, BGLMPIO_CIO_DEXCH, BGLMPIO_CIO_OTHREQ ) > #endif > > /* my_req[] and count_my_req_per_proc aren't needed at this point, so > * let's free the memory > */ > ADIOI_Free(count_my_req_per_proc); > for (i=0; i if (my_req[i].count) { > ADIOI_Free(my_req[i].offsets); > ADIOI_Free(my_req[i].lens); > } > } > ADIOI_Free(my_req); > > > /* read data in sizes of no more than ADIOI_Coll_bufsize, > * communicate, and fill user buf. > */ > ADIOI_Read_and_exch(fd, buf, datatype, nprocs, myrank, > others_req, offset_list, > len_list, contig_access_count, min_st_offset, > fd_size, fd_start, fd_end, buf_idx, error_code); > > #if BGL_PROFILE > BGLMPIO_T_CIO_SET_GET( 0, r, 1, 0, 1, BGLMPIO_CIO_LAST, BGLMPIO_CIO_T_DEXCH ) > BGLMPIO_T_CIO_SET_GET( 0, r, 0, 0, 1, BGLMPIO_CIO_LAST, BGLMPIO_CIO_T_MPIO_CRW ) > > BGLMPIO_T_CIO_REPORT( 0, r, fd, myrank ) > #endif > > if (!buftype_is_contig) ADIOI_Delete_flattened(datatype); > > /* free all memory allocated for collective I/O */ > for (i=0; i if (others_req[i].count) { > ADIOI_Free(others_req[i].offsets); > ADIOI_Free(others_req[i].lens); > ADIOI_Free(others_req[i].mem_ptrs); > } > } > ADIOI_Free(others_req); > > ADIOI_Free(buf_idx); > ADIOI_Free(offset_list); > ADIOI_Free(len_list); > ADIOI_Free(st_offsets); > ADIOI_Free(end_offsets); > ADIOI_Free(fd_start); > ADIOI_Free(fd_end); > > #ifdef HAVE_STATUS_SET_BYTES > MPI_Type_size(datatype, &size); > bufsize = size * count; > MPIR_Status_set_bytes(status, datatype, bufsize); > /* This is a temporary way of filling in status. The right way is to > keep track of how much data was actually read and placed in buf > during collective I/O. */ > #endif > > fd->fp_sys_posn = -1; /* set it to null. */ > } > > #if 0 > void ADIOI_Calc_my_off_len(ADIO_File fd, int bufcount, MPI_Datatype > datatype, int file_ptr_type, ADIO_Offset > offset, ADIO_Offset **offset_list_ptr, int > **len_list_ptr, ADIO_Offset *start_offset_ptr, > ADIO_Offset *end_offset_ptr, int > *contig_access_count_ptr) > { > int filetype_size, buftype_size, etype_size; > int i, j, k, frd_size=0, old_frd_size=0, st_index=0; > int n_filetypes, etype_in_filetype; > ADIO_Offset abs_off_in_filetype=0; > int bufsize, sum, n_etypes_in_filetype, size_in_filetype; > int contig_access_count, *len_list, flag, filetype_is_contig; > MPI_Aint filetype_extent, filetype_lb; > ADIOI_Flatlist_node *flat_file; > ADIO_Offset *offset_list, off, end_offset=0, disp; > > /* For this process's request, calculate the list of offsets and > lengths in the file and determine the start and end offsets. */ > > ADIOI_Datatype_iscontig(fd->filetype, &filetype_is_contig); > > MPI_Type_size(fd->filetype, &filetype_size); > MPI_Type_extent(fd->filetype, &filetype_extent); > MPI_Type_lb(fd->filetype, &filetype_lb); > MPI_Type_size(datatype, &buftype_size); > etype_size = fd->etype_size; > > if ( ! filetype_size ) { > *contig_access_count_ptr = 0; > *offset_list_ptr = (ADIO_Offset *) ADIOI_Malloc(2*sizeof(ADIO_Offset)); > *len_list_ptr = (int *) ADIOI_Malloc(2*sizeof(int)); > /* 2 is for consistency. everywhere I malloc one more than needed */ > > offset_list = *offset_list_ptr; > len_list = *len_list_ptr; > offset_list[0] = (file_ptr_type == ADIO_INDIVIDUAL) ? fd->fp_ind : > fd->disp + etype_size * offset; > len_list[0] = 0; > *start_offset_ptr = offset_list[0]; > *end_offset_ptr = offset_list[0] + len_list[0] - 1; > > return; > } > > if (filetype_is_contig) { > *contig_access_count_ptr = 1; > *offset_list_ptr = (ADIO_Offset *) ADIOI_Malloc(2*sizeof(ADIO_Offset)); > *len_list_ptr = (int *) ADIOI_Malloc(2*sizeof(int)); > /* 2 is for consistency. everywhere I malloc one more than needed */ > > offset_list = *offset_list_ptr; > len_list = *len_list_ptr; > offset_list[0] = (file_ptr_type == ADIO_INDIVIDUAL) ? fd->fp_ind : > fd->disp + etype_size * offset; > len_list[0] = bufcount * buftype_size; > *start_offset_ptr = offset_list[0]; > *end_offset_ptr = offset_list[0] + len_list[0] - 1; > > /* update file pointer */ > if (file_ptr_type == ADIO_INDIVIDUAL) fd->fp_ind = *end_offset_ptr + 1; > } > > else { > > /* First calculate what size of offset_list and len_list to allocate */ > > /* filetype already flattened in ADIO_Open or ADIO_Fcntl */ > flat_file = ADIOI_Flatlist; > while (flat_file->type != fd->filetype) flat_file = flat_file->next; > disp = fd->disp; > > if (file_ptr_type == ADIO_INDIVIDUAL) { > offset = fd->fp_ind; /* in bytes */ > n_filetypes = -1; > flag = 0; > while (!flag) { > n_filetypes++; > for (i=0; icount; i++) { > if (disp + flat_file->indices[i] + > (ADIO_Offset) n_filetypes*filetype_extent + > flat_file->blocklens[i] >= offset) > { > st_index = i; > frd_size = (int) (disp + flat_file->indices[i] + > (ADIO_Offset) n_filetypes*filetype_extent > + flat_file->blocklens[i] - offset); > flag = 1; > break; > } > } > } > } > else { > n_etypes_in_filetype = filetype_size/etype_size; > n_filetypes = (int) (offset / n_etypes_in_filetype); > etype_in_filetype = (int) (offset % n_etypes_in_filetype); > size_in_filetype = etype_in_filetype * etype_size; > > sum = 0; > for (i=0; icount; i++) { > sum += flat_file->blocklens[i]; > if (sum > size_in_filetype) { > st_index = i; > frd_size = sum - size_in_filetype; > abs_off_in_filetype = flat_file->indices[i] + > size_in_filetype - (sum - flat_file->blocklens[i]); > break; > } > } > > /* abs. offset in bytes in the file */ > offset = disp + (ADIO_Offset) n_filetypes*filetype_extent + > abs_off_in_filetype; > } > > /* calculate how much space to allocate for offset_list, len_list */ > > old_frd_size = frd_size; > contig_access_count = i = 0; > j = st_index; > bufsize = buftype_size * bufcount; > frd_size = ADIOI_MIN(frd_size, bufsize); > while (i < bufsize) { > if (frd_size) contig_access_count++; > i += frd_size; > j = (j + 1) % flat_file->count; > frd_size = ADIOI_MIN(flat_file->blocklens[j], bufsize-i); > } > > /* allocate space for offset_list and len_list */ > > *offset_list_ptr = (ADIO_Offset *) > ADIOI_Malloc((contig_access_count+1)*sizeof(ADIO_Offset)); > *len_list_ptr = (int *) ADIOI_Malloc((contig_access_count+1)*sizeof(int)); > /* +1 to avoid a 0-size malloc */ > > offset_list = *offset_list_ptr; > len_list = *len_list_ptr; > > /* find start offset, end offset, and fill in offset_list and len_list */ > > *start_offset_ptr = offset; /* calculated above */ > > i = k = 0; > j = st_index; > off = offset; > frd_size = ADIOI_MIN(old_frd_size, bufsize); > while (i < bufsize) { > if (frd_size) { > offset_list[k] = off; > len_list[k] = frd_size; > k++; > } > i += frd_size; > end_offset = off + frd_size - 1; > > /* Note: end_offset points to the last byte-offset that will be accessed. > e.g., if start_offset=0 and 100 bytes to be read, end_offset=99*/ > > if (off + frd_size < disp + flat_file->indices[j] + > flat_file->blocklens[j] + > (ADIO_Offset) n_filetypes*filetype_extent) > { > off += frd_size; > /* did not reach end of contiguous block in filetype. > * no more I/O needed. off is incremented by frd_size. > */ > } > else { > if (j < (flat_file->count - 1)) j++; > else { > /* hit end of flattened filetype; > * start at beginning again > */ > j = 0; > n_filetypes++; > } > off = disp + flat_file->indices[j] + > (ADIO_Offset) n_filetypes*filetype_extent; > frd_size = ADIOI_MIN(flat_file->blocklens[j], bufsize-i); > } > } > > /* update file pointer */ > if (file_ptr_type == ADIO_INDIVIDUAL) fd->fp_ind = off; > > *contig_access_count_ptr = contig_access_count; > *end_offset_ptr = end_offset; > } > } > #endif > > static void ADIOI_Read_and_exch(ADIO_File fd, void *buf, MPI_Datatype > datatype, int nprocs, > int myrank, ADIOI_Access > *others_req, ADIO_Offset *offset_list, > int *len_list, int contig_access_count, ADIO_Offset > min_st_offset, ADIO_Offset fd_size, > ADIO_Offset *fd_start, ADIO_Offset *fd_end, > int *buf_idx, int *error_code) > { > /* Read in sizes of no more than coll_bufsize, an info parameter. > Send data to appropriate processes. > Place recd. data in user buf. > The idea is to reduce the amount of extra memory required for > collective I/O. If all data were read all at once, which is much > easier, it would require temp space more than the size of user_buf, > which is often unacceptable. For example, to read a distributed > array from a file, where each local array is 8Mbytes, requiring > at least another 8Mbytes of temp space is unacceptable. */ > > int i, j, m, size, ntimes, max_ntimes, buftype_is_contig; > ADIO_Offset st_loc=-1, end_loc=-1, off, done, real_off, req_off; > char *read_buf = NULL, *tmp_buf; > int *curr_offlen_ptr, *count, *send_size, *recv_size; > int *partial_send, *recd_from_proc, *start_pos, for_next_iter; > int real_size, req_len, flag, for_curr_iter, rank; > MPI_Status status; > ADIOI_Flatlist_node *flat_buf=NULL; > MPI_Aint buftype_extent; > int coll_bufsize; > > int iii; > > *error_code = MPI_SUCCESS; /* changed below if error */ > /* only I/O errors are currently reported */ > > /* calculate the number of reads of size coll_bufsize > to be done by each process and the max among all processes. > That gives the no. of communication phases as well. > coll_bufsize is obtained from the hints object. */ > > coll_bufsize = fd->hints->cb_buffer_size; > > /* grab some initial values for st_loc and end_loc */ > for (i=0; i < nprocs; i++) { > if (others_req[i].count) { > st_loc = others_req[i].offsets[0]; > end_loc = others_req[i].offsets[0]; > break; > } > } > > /* now find the real values */ > for (i=0; i < nprocs; i++) > for (j=0; j st_loc = ADIOI_MIN(st_loc, others_req[i].offsets[j]); > end_loc = ADIOI_MAX(end_loc, (others_req[i].offsets[j] > + others_req[i].lens[j] - 1)); > } > > /* calculate ntimes, the number of times this process must perform I/O > * operations in order to complete all the requests it has received. > * the need for multiple I/O operations comes from the restriction that > * we only use coll_bufsize bytes of memory for internal buffering. > */ > if ((st_loc==-1) && (end_loc==-1)) { > /* this process does no I/O. */ > ntimes = 0; > } > else { > /* ntimes=ceiling_div(end_loc - st_loc + 1, coll_bufsize)*/ > ntimes = (int) ((end_loc - st_loc + coll_bufsize)/coll_bufsize); > } > > MPI_Allreduce(&ntimes, &max_ntimes, 1, MPI_INT, MPI_MAX, fd->comm); > > if (ntimes) read_buf = (char *) ADIOI_Malloc(coll_bufsize); > > curr_offlen_ptr = (int *) ADIOI_Calloc(nprocs, sizeof(int)); > /* its use is explained below. calloc initializes to 0. */ > > count = (int *) ADIOI_Malloc(nprocs * sizeof(int)); > /* to store count of how many off-len pairs per proc are satisfied > in an iteration. */ > > partial_send = (int *) ADIOI_Calloc(nprocs, sizeof(int)); > /* if only a portion of the last off-len pair is sent to a process > in a particular iteration, the length sent is stored here. > calloc initializes to 0. */ > > send_size = (int *) ADIOI_Malloc(nprocs * sizeof(int)); > /* total size of data to be sent to each proc. in an iteration */ > > recv_size = (int *) ADIOI_Malloc(nprocs * sizeof(int)); > /* total size of data to be recd. from each proc. in an iteration. > Of size nprocs so that I can use MPI_Alltoall later. */ > > recd_from_proc = (int *) ADIOI_Calloc(nprocs, sizeof(int)); > /* amount of data recd. so far from each proc. Used in > ADIOI_Fill_user_buffer. initialized to 0 here. */ > > start_pos = (int *) ADIOI_Malloc(nprocs*sizeof(int)); > /* used to store the starting value of curr_offlen_ptr[i] in > this iteration */ > > ADIOI_Datatype_iscontig(datatype, &buftype_is_contig); > if (!buftype_is_contig) { > ADIOI_Flatten_datatype(datatype); > flat_buf = ADIOI_Flatlist; > while (flat_buf->type != datatype) flat_buf = flat_buf->next; > } > MPI_Type_extent(datatype, &buftype_extent); > > done = 0; > off = st_loc; > for_curr_iter = for_next_iter = 0; > > MPI_Comm_rank(fd->comm, &rank); > > #ifdef PROFILE > MPE_Log_event(14, 0, "end computation"); > #endif > > for (m=0; m /* read buf of size coll_bufsize (or less) */ > /* go through all others_req and check if any are satisfied > by the current read */ > > /* since MPI guarantees that displacements in filetypes are in > monotonically nondecreasing order, I can maintain a pointer > (curr_offlen_ptr) to > current off-len pair for each process in others_req and scan > further only from there. There is still a problem of filetypes > such as: (1, 2, 3 are not process nos. They are just numbers for > three chunks of data, specified by a filetype.) > > 1 -------!-- > 2 -----!---- > 3 --!----- > > where ! indicates where the current read_size limitation cuts > through the filetype. I resolve this by reading up to !, but > filling the communication buffer only for 1. I copy the portion > left over for 2 into a tmp_buf for use in the next > iteration. i.e., 2 and 3 will be satisfied in the next > iteration. This simplifies filling in the user's buf at the > other end, as only one off-len pair with incomplete data > will be sent. I also don't need to send the individual > offsets and lens along with the data, as the data is being > sent in a particular order. */ > > /* off = start offset in the file for the data actually read in > this iteration > size = size of data read corresponding to off > real_off = off minus whatever data was retained in memory from > previous iteration for cases like 2, 3 illustrated above > real_size = size plus the extra corresponding to real_off > req_off = off in file for a particular contiguous request > minus what was satisfied in previous iteration > req_size = size corresponding to req_off */ > > #ifdef PROFILE > MPE_Log_event(13, 0, "start computation"); > #endif > size = (int) (ADIOI_MIN(coll_bufsize, end_loc-st_loc+1-done)); > real_off = off - for_curr_iter; > real_size = size + for_curr_iter; > > for (i=0; i for_next_iter = 0; > > for (i=0; i /* FPRINTF(stderr, "rank %d, i %d, others_count %d\n", rank, i, others_req[i].count); */ > if (others_req[i].count) { > start_pos[i] = curr_offlen_ptr[i]; > for (j=curr_offlen_ptr[i]; j j++) { > if (partial_send[i]) { > /* this request may have been partially > satisfied in the previous iteration. */ > req_off = others_req[i].offsets[j] + > partial_send[i]; > req_len = others_req[i].lens[j] - > partial_send[i]; > partial_send[i] = 0; > /* modify the off-len pair to reflect this change */ > others_req[i].offsets[j] = req_off; > others_req[i].lens[j] = req_len; > } > else { > req_off = others_req[i].offsets[j]; > req_len = others_req[i].lens[j]; > } > if (req_off < real_off + real_size) { > count[i]++; > MPI_Address(read_buf+req_off-real_off, > &(others_req[i].mem_ptrs[j])); > send_size[i] += (int)(ADIOI_MIN(real_off + (ADIO_Offset)real_size - > req_off, req_len)); > > if (real_off+real_size-req_off < req_len) { > partial_send[i] = (int) (real_off+real_size- > req_off); > if ((j+1 < others_req[i].count) && > (others_req[i].offsets[j+1] < > real_off+real_size)) { > /* this is the case illustrated in the > figure above. */ > for_next_iter = (int) (ADIOI_MAX(for_next_iter, > real_off + real_size - > others_req[i].offsets[j+1])); > /* max because it must cover requests > from different processes */ > } > break; > } > } > else break; > } > curr_offlen_ptr[i] = j; > } > } > > flag = 0; > for (i=0; i if (count[i]) flag = 1; > > #ifdef PROFILE > MPE_Log_event(14, 0, "end computation"); > #endif > if (flag) { > ADIO_ReadContig(fd, read_buf+for_curr_iter, size, MPI_BYTE, > ADIO_EXPLICIT_OFFSET, off, &status, error_code); > /* > printf( "\tread_coll: 700, data read [%3d] = ", size ); > for (iii=0; iii printf( "\n" ); > */ > > if (*error_code != MPI_SUCCESS) return; > } > > for_curr_iter = for_next_iter; > > #ifdef PROFILE > MPE_Log_event(7, 0, "start communication"); > #endif > if (bglmpio_comm == 1) > ADIOI_R_Exchange_data(fd, buf, flat_buf, offset_list, len_list, > send_size, recv_size, count, > start_pos, partial_send, recd_from_proc, nprocs, > myrank, > buftype_is_contig, contig_access_count, > min_st_offset, fd_size, fd_start, fd_end, > others_req, > m, buftype_extent, buf_idx); > else > if (bglmpio_comm == 0) { > ADIOI_R_Exchange_data_alltoallv(fd, buf, flat_buf, offset_list, len_list, > send_size, recv_size, count, > start_pos, partial_send, recd_from_proc, nprocs, > myrank, > buftype_is_contig, contig_access_count, > min_st_offset, fd_size, fd_start, fd_end, > others_req, > m, buftype_extent, buf_idx); > } > > > #ifdef PROFILE > MPE_Log_event(8, 0, "end communication"); > #endif > > if (for_next_iter) { > tmp_buf = (char *) ADIOI_Malloc(for_next_iter); > memcpy(tmp_buf, read_buf+real_size-for_next_iter, for_next_iter); > ADIOI_Free(read_buf); > read_buf = (char *) ADIOI_Malloc(for_next_iter+coll_bufsize); > memcpy(read_buf, tmp_buf, for_next_iter); > ADIOI_Free(tmp_buf); > } > > off += size; > done += size; > } > > for (i=0; i #ifdef PROFILE > MPE_Log_event(7, 0, "start communication"); > #endif > for (m=ntimes; m /* nothing to send, but check for recv. */ > > if (bglmpio_comm == 1) > ADIOI_R_Exchange_data(fd, buf, flat_buf, offset_list, len_list, > send_size, recv_size, count, > start_pos, partial_send, recd_from_proc, nprocs, > myrank, > buftype_is_contig, contig_access_count, > min_st_offset, fd_size, fd_start, fd_end, > others_req, m, > buftype_extent, buf_idx); > else /* strncmp( env_switch, "alltoall", 8 ) == 0 */ > if (bglmpio_comm == 0) > ADIOI_R_Exchange_data_alltoallv(fd, buf, flat_buf, offset_list, len_list, > send_size, recv_size, count, > start_pos, partial_send, recd_from_proc, nprocs, > myrank, > buftype_is_contig, contig_access_count, > min_st_offset, fd_size, fd_start, fd_end, > others_req, > m, buftype_extent, buf_idx); > > #ifdef PROFILE > MPE_Log_event(8, 0, "end communication"); > #endif > > if (ntimes) ADIOI_Free(read_buf); > ADIOI_Free(curr_offlen_ptr); > ADIOI_Free(count); > ADIOI_Free(partial_send); > ADIOI_Free(send_size); > ADIOI_Free(recv_size); > ADIOI_Free(recd_from_proc); > ADIOI_Free(start_pos); > } > > static void ADIOI_R_Exchange_data(ADIO_File fd, void *buf, ADIOI_Flatlist_node > *flat_buf, ADIO_Offset *offset_list, int > *len_list, int *send_size, int *recv_size, > int *count, int *start_pos, int *partial_send, > int *recd_from_proc, int nprocs, > int myrank, int > buftype_is_contig, int contig_access_count, > ADIO_Offset min_st_offset, ADIO_Offset fd_size, > ADIO_Offset *fd_start, ADIO_Offset *fd_end, > ADIOI_Access *others_req, > int iter, MPI_Aint buftype_extent, int *buf_idx) > { > int i, j, k=0, tmp=0, nprocs_recv, nprocs_send; > char **recv_buf = NULL; > MPI_Request *requests; > MPI_Datatype send_type; > MPI_Status *statuses; > > /* exchange send_size info so that each process knows how much to > receive from whom and how much memory to allocate. */ > > MPI_Alltoall(send_size, 1, MPI_INT, recv_size, 1, MPI_INT, fd->comm); > > nprocs_recv = 0; > for (i=0; i < nprocs; i++) if (recv_size[i]) nprocs_recv++; > > nprocs_send = 0; > for (i=0; i > requests = (MPI_Request *) > ADIOI_Malloc((nprocs_send+nprocs_recv+1)*sizeof(MPI_Request)); > /* +1 to avoid a 0-size malloc */ > > /* post recvs. if buftype_is_contig, data can be directly recd. into > user buf at location given by buf_idx. else use recv_buf. */ > > if (buftype_is_contig) { > j = 0; > for (i=0; i < nprocs; i++) > if (recv_size[i]) { > MPI_Irecv(((char *) buf) + buf_idx[i], recv_size[i], > MPI_BYTE, i, myrank+i+100*iter, fd->comm, requests+j); > j++; > buf_idx[i] += recv_size[i]; > } > } > else { > /* allocate memory for recv_buf and post receives */ > recv_buf = (char **) ADIOI_Malloc(nprocs * sizeof(char*)); > for (i=0; i < nprocs; i++) > if (recv_size[i]) recv_buf[i] = > (char *) ADIOI_Malloc(recv_size[i]); > > j = 0; > for (i=0; i < nprocs; i++) > if (recv_size[i]) { > MPI_Irecv(recv_buf[i], recv_size[i], MPI_BYTE, i, > myrank+i+100*iter, fd->comm, requests+j); > j++; > /* FPRINTF(stderr, "node %d, recv_size %d, tag %d \n", > myrank, recv_size[i], myrank+i+100*iter); */ > } > } > > /* create derived datatypes and send data */ > > j = 0; > for (i=0; i if (send_size[i]) { > /* take care if the last off-len pair is a partial send */ > if (partial_send[i]) { > k = start_pos[i] + count[i] - 1; > tmp = others_req[i].lens[k]; > others_req[i].lens[k] = partial_send[i]; > } > MPI_Type_hindexed(count[i], > &(others_req[i].lens[start_pos[i]]), > &(others_req[i].mem_ptrs[start_pos[i]]), > MPI_BYTE, &send_type); > /* absolute displacement; use MPI_BOTTOM in send */ > MPI_Type_commit(&send_type); > MPI_Isend(MPI_BOTTOM, 1, send_type, i, myrank+i+100*iter, > fd->comm, requests+nprocs_recv+j); > MPI_Type_free(&send_type); > if (partial_send[i]) others_req[i].lens[k] = tmp; > j++; > } > } > > statuses = (MPI_Status *) ADIOI_Malloc((nprocs_send+nprocs_recv+1) * \ > sizeof(MPI_Status)); > /* +1 to avoid a 0-size malloc */ > > /* wait on the receives */ > if (nprocs_recv) { > #ifdef NEEDS_MPI_TEST > j = 0; > while (!j) MPI_Testall(nprocs_recv, requests, &j, statuses); > #else > MPI_Waitall(nprocs_recv, requests, statuses); > #endif > > /* if noncontiguous, to the copies from the recv buffers */ > if (!buftype_is_contig) > ADIOI_Fill_user_buffer(fd, buf, flat_buf, recv_buf, > offset_list, len_list, recv_size, > requests, statuses, recd_from_proc, > nprocs, contig_access_count, > min_st_offset, fd_size, fd_start, fd_end, > buftype_extent); > } > > /* wait on the sends*/ > MPI_Waitall(nprocs_send, requests+nprocs_recv, statuses+nprocs_recv); > > ADIOI_Free(statuses); > ADIOI_Free(requests); > > if (!buftype_is_contig) { > for (i=0; i < nprocs; i++) > if (recv_size[i]) ADIOI_Free(recv_buf[i]); > ADIOI_Free(recv_buf); > } > } > > > #define ADIOI_BUF_INCR \ > { \ > while (buf_incr) { \ > size_in_buf = ADIOI_MIN(buf_incr, flat_buf_sz); \ > user_buf_idx += size_in_buf; \ > flat_buf_sz -= size_in_buf; \ > if (!flat_buf_sz) { \ > if (flat_buf_idx < (flat_buf->count - 1)) flat_buf_idx++; \ > else { \ > flat_buf_idx = 0; \ > n_buftypes++; \ > } \ > user_buf_idx = flat_buf->indices[flat_buf_idx] + \ > n_buftypes*buftype_extent; \ > flat_buf_sz = flat_buf->blocklens[flat_buf_idx]; \ > } \ > buf_incr -= size_in_buf; \ > } \ > } > > > #define ADIOI_BUF_COPY \ > { \ > while (size) { \ > size_in_buf = ADIOI_MIN(size, flat_buf_sz); \ > memcpy(((char *) buf) + user_buf_idx, \ > &(recv_buf[p][recv_buf_idx[p]]), size_in_buf); \ > recv_buf_idx[p] += size_in_buf; \ > user_buf_idx += size_in_buf; \ > flat_buf_sz -= size_in_buf; \ > if (!flat_buf_sz) { \ > if (flat_buf_idx < (flat_buf->count - 1)) flat_buf_idx++; \ > else { \ > flat_buf_idx = 0; \ > n_buftypes++; \ > } \ > user_buf_idx = flat_buf->indices[flat_buf_idx] + \ > n_buftypes*buftype_extent; \ > flat_buf_sz = flat_buf->blocklens[flat_buf_idx]; \ > } \ > size -= size_in_buf; \ > buf_incr -= size_in_buf; \ > } \ > ADIOI_BUF_INCR \ > } > > > static void ADIOI_Fill_user_buffer(ADIO_File fd, void *buf, ADIOI_Flatlist_node > *flat_buf, char **recv_buf, ADIO_Offset > *offset_list, int *len_list, > int *recv_size, > MPI_Request *requests, MPI_Status *statuses, > int *recd_from_proc, int nprocs, > int contig_access_count, > ADIO_Offset min_st_offset, > ADIO_Offset fd_size, ADIO_Offset *fd_start, > ADIO_Offset *fd_end, > MPI_Aint buftype_extent) > { > /* this function is only called if buftype is not contig */ > > int i, p, flat_buf_idx, size, buf_incr; > int flat_buf_sz, size_in_buf, n_buftypes; > ADIO_Offset off, len, rem_len, user_buf_idx; > > int *curr_from_proc, *done_from_proc, *recv_buf_idx; > > /* curr_from_proc[p] = amount of data recd from proc. p that has already > been accounted for so far > done_from_proc[p] = amount of data already recd from proc. p and > filled into user buffer in previous iterations > user_buf_idx = current location in user buffer > recv_buf_idx[p] = current location in recv_buf of proc. p */ > curr_from_proc = (int *) ADIOI_Malloc(nprocs * sizeof(int)); > done_from_proc = (int *) ADIOI_Malloc(nprocs * sizeof(int)); > recv_buf_idx = (int *) ADIOI_Malloc(nprocs * sizeof(int)); > > for (i=0; i < nprocs; i++) { > recv_buf_idx[i] = curr_from_proc[i] = 0; > done_from_proc[i] = recd_from_proc[i]; > } > > user_buf_idx = flat_buf->indices[0]; > flat_buf_idx = 0; > n_buftypes = 0; > flat_buf_sz = flat_buf->blocklens[0]; > > /* flat_buf_idx = current index into flattened buftype > flat_buf_sz = size of current contiguous component in > flattened buf */ > > for (i=0; i off = offset_list[i]; > rem_len = (ADIO_Offset) len_list[i]; > > /* this request may span the file domains of more than one process */ > while (rem_len > 0) { > len = rem_len; > /* NOTE: len value is modified by ADIOI_Calc_aggregator() to be no > * longer than the single region that processor "p" is responsible > * for. > */ > p = ADIOI_BGL_Calc_aggregator(fd, > off, > min_st_offset, > &len, > fd_size, > fd_start, > fd_end); > > if (recv_buf_idx[p] < recv_size[p]) { > if (curr_from_proc[p]+len > done_from_proc[p]) { > if (done_from_proc[p] > curr_from_proc[p]) { > size = (int)ADIOI_MIN(curr_from_proc[p] + len - > done_from_proc[p], recv_size[p]-recv_buf_idx[p]); > buf_incr = done_from_proc[p] - curr_from_proc[p]; > ADIOI_BUF_INCR > buf_incr = (int)(curr_from_proc[p]+len-done_from_proc[p]); > curr_from_proc[p] = done_from_proc[p] + size; > ADIOI_BUF_COPY > } > else { > size = (int)ADIOI_MIN(len,recv_size[p]-recv_buf_idx[p]); > buf_incr = (int)len; > curr_from_proc[p] += size; > ADIOI_BUF_COPY > } > } > else { > curr_from_proc[p] += (int)len; > buf_incr = (int)len; > ADIOI_BUF_INCR > } > } > else { > buf_incr = (int)len; > ADIOI_BUF_INCR > } > off += len; > rem_len -= len; > } > } > for (i=0; i < nprocs; i++) > if (recv_size[i]) recd_from_proc[i] = curr_from_proc[i]; > > ADIOI_Free(curr_from_proc); > ADIOI_Free(done_from_proc); > ADIOI_Free(recv_buf_idx); > } > > static void ADIOI_R_Exchange_data_alltoallv( > ADIO_File fd, void *buf, ADIOI_Flatlist_node > *flat_buf, ADIO_Offset *offset_list, int > *len_list, int *send_size, int *recv_size, > int *count, int *start_pos, int *partial_send, > int *recd_from_proc, int nprocs, > int myrank, int > buftype_is_contig, int contig_access_count, > ADIO_Offset min_st_offset, ADIO_Offset fd_size, > ADIO_Offset *fd_start, ADIO_Offset *fd_end, > ADIOI_Access *others_req, > int iter, MPI_Aint buftype_extent, int *buf_idx) > { > int i, j, k=0, tmp=0, nprocs_recv, nprocs_send; > char **recv_buf = NULL; > MPI_Request *requests; > MPI_Datatype send_type; > MPI_Status *statuses; > int rtail, stail; > char *sbuf_ptr, *from_ptr; > int len; > int *sdispls, *rdispls; > char *all_recv_buf, *all_send_buf; > > /* exchange send_size info so that each process knows how much to > receive from whom and how much memory to allocate. */ > MPI_Alltoall(send_size, 1, MPI_INT, recv_size, 1, MPI_INT, fd->comm); > > nprocs_recv = 0; > for (i=0; i > nprocs_send = 0; > for (i=0; i > /* receiver side data structures */ > rdispls = (int *) ADIOI_Malloc( nprocs * sizeof(int) ); > rtail = 0; > for (i=0; i > /* data buffer */ > all_recv_buf = (char *) ADIOI_Malloc( rtail ); > recv_buf = (char **) ADIOI_Malloc(nprocs * sizeof(char *)); > for (i=0; i > /* sender side data structures */ > sdispls = (int *) ADIOI_Malloc( nprocs * sizeof(int) ); > stail = 0; > for (i=0; i > /* data buffer */ > all_send_buf = (char *) ADIOI_Malloc( stail ); > for (i=0; i { > if (send_size[i]) { > if (partial_send[i]) { > k = start_pos[i] + count[i] - 1; > tmp = others_req[i].lens[k]; > others_req[i].lens[k] = partial_send[i]; > } > sbuf_ptr = all_send_buf + sdispls[i]; > for (j=0; j from_ptr = (char *)( others_req[i].mem_ptrs[ start_pos[i]+j ] ); > len = others_req[i].lens[ start_pos[i]+j ] ; > memcpy( sbuf_ptr, from_ptr, len ); > sbuf_ptr += len; > } > if (partial_send[i]) others_req[i].lens[k] = tmp; > } > } > > #if 0 > printf( "\tsend_size = " ); > for (i=0; i printf( "\n" ); > printf( "\trecv_size = " ); > for (i=0; i printf( "\n" ); > printf( "\tsdispls = " ); > for (i=0; i printf( "\n" ); > printf( "\trdispls = " ); > for (i=0; i printf( "\n" ); > printf( "\ttails = %4d, %4d\n", stail, rtail ); > #endif > #if 0 > if (nprocs_send) { > printf( "\tall_send_buf = " ); > for (i=0; i printf( "\n" ); > } > #endif > > /* alltoallv */ > MPI_Alltoallv( > all_send_buf, send_size, sdispls, MPI_BYTE, > all_recv_buf, recv_size, rdispls, MPI_BYTE, > fd->comm ); > > #if 0 > printf( "\tall_recv_buf = " ); > for (i=131072; i<131073; i++) { printf( "%2d,", all_recv_buf [i] ); } > printf( "\n" ); > #endif > > /* unpack at the receiver side */ > if (nprocs_recv) { > if (!buftype_is_contig) > ADIOI_Fill_user_buffer(fd, buf, flat_buf, recv_buf, > offset_list, len_list, recv_size, > requests, statuses, /* never used inside */ > recd_from_proc, > nprocs, contig_access_count, > min_st_offset, fd_size, fd_start, fd_end, > buftype_extent); > else { > rtail = 0; > for (i=0; i < nprocs; i++) > if (recv_size[i]) { > memcpy( (char *)buf + buf_idx[i], all_recv_buf + rtail, recv_size[i] ); > buf_idx[i] += recv_size[i]; > rtail += recv_size[i]; > } > } > } > > ADIOI_Free( all_send_buf ); > ADIOI_Free( all_recv_buf ); > return; > } diff -rN mpich2-1.0.7rc1/src/mpi/romio/adio/ad_bgl/ad_bgl_read.c bgp-mpich2/src/mpi/romio/adio/ad_bgl/ad_bgl_read.c 0a1,501 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file ad_bgl_read.c > * \brief ??? > */ > > /* -*- Mode: C; c-basic-offset:4 ; -*- */ > /* > * Copyright (C) 1997 University of Chicago. > * See COPYRIGHT notice in top-level directory. > */ > > #include "ad_bgl.h" > #include "adio_extern.h" > > #include "ad_bgl_tuning.h" > > void ADIOI_BGL_ReadContig(ADIO_File fd, void *buf, int count, > MPI_Datatype datatype, int file_ptr_type, > ADIO_Offset offset, ADIO_Status *status, int *error_code) > { > int err=-1, datatype_size, len; > static char myname[] = "ADIOI_BGL_READCONTIG"; > > #if BGL_PROFILE > /* timing */ > double io_time, io_time2; > > if (bglmpio_timing) { > io_time = MPI_Wtime(); > bglmpio_prof_cr[ BGLMPIO_CIO_DATA_SIZE ] += len; > } > #endif > > MPI_Type_size(datatype, &datatype_size); > len = datatype_size * count; > > #if BGL_PROFILE > > if (file_ptr_type == ADIO_EXPLICIT_OFFSET) { > if (bglmpio_timing2) io_time2 = MPI_Wtime(); > if (fd->fp_sys_posn != offset) > lseek(fd->fd_sys, offset, SEEK_SET); > if (bglmpio_timing2) bglmpio_prof_cr[ BGLMPIO_CIO_T_SEEK ] += (MPI_Wtime() - io_time2); > if (fd->atomicity) > ADIOI_WRITE_LOCK(fd, offset, SEEK_SET, len); > else ADIOI_READ_LOCK(fd, offset, SEEK_SET, len); > if (bglmpio_timing2) io_time2 = MPI_Wtime(); > err = read(fd->fd_sys, buf, len); > if (bglmpio_timing2) bglmpio_prof_cr[ BGLMPIO_CIO_T_POSI_RW ] += (MPI_Wtime() - io_time2); > ADIOI_UNLOCK(fd, offset, SEEK_SET, len); > fd->fp_sys_posn = offset + err; > /* individual file pointer not updated */ > } > else { /* read from curr. location of ind. file pointer */ > offset = fd->fp_ind; > if (bglmpio_timing2) io_time2 = MPI_Wtime(); > if (fd->fp_sys_posn != fd->fp_ind) > lseek(fd->fd_sys, fd->fp_ind, SEEK_SET); > if (bglmpio_timing2) bglmpio_prof_cr[ BGLMPIO_CIO_T_SEEK ] += (MPI_Wtime() - io_time2); > if (fd->atomicity) > ADIOI_WRITE_LOCK(fd, offset, SEEK_SET, len); > else ADIOI_READ_LOCK(fd, offset, SEEK_SET, len); > if (bglmpio_timing2) io_time2 = MPI_Wtime(); > err = read(fd->fd_sys, buf, len); > if (bglmpio_timing2) bglmpio_prof_cr[ BGLMPIO_CIO_T_POSI_RW ] += (MPI_Wtime() - io_time2); > ADIOI_UNLOCK(fd, offset, SEEK_SET, len); > fd->fp_ind += err; > fd->fp_sys_posn = fd->fp_ind; > } > > #else /* BGL_PROFILE */ > > if (file_ptr_type == ADIO_EXPLICIT_OFFSET) { > if (fd->fp_sys_posn != offset) > lseek(fd->fd_sys, offset, SEEK_SET); > if (fd->atomicity) > ADIOI_WRITE_LOCK(fd, offset, SEEK_SET, len); > else ADIOI_READ_LOCK(fd, offset, SEEK_SET, len); > err = read(fd->fd_sys, buf, len); > ADIOI_UNLOCK(fd, offset, SEEK_SET, len); > fd->fp_sys_posn = offset + err; > /* individual file pointer not updated */ > } > else { /* read from curr. location of ind. file pointer */ > offset = fd->fp_ind; > if (fd->fp_sys_posn != fd->fp_ind) > lseek(fd->fd_sys, fd->fp_ind, SEEK_SET); > if (fd->atomicity) > ADIOI_WRITE_LOCK(fd, offset, SEEK_SET, len); > else ADIOI_READ_LOCK(fd, offset, SEEK_SET, len); > err = read(fd->fd_sys, buf, len); > ADIOI_UNLOCK(fd, offset, SEEK_SET, len); > fd->fp_ind += err; > fd->fp_sys_posn = fd->fp_ind; > } > > #endif /* BGL_PROFILE */ > > #if BGL_PROFILE > if (bglmpio_timing) bglmpio_prof_cr[ BGLMPIO_CIO_T_MPIO_RW ] += (MPI_Wtime() - io_time); > #endif > > /* --BEGIN ERROR HANDLING-- */ > if (err == -1) { > *error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, > myname, __LINE__, MPI_ERR_IO, > "**io", "**io %s", strerror(errno)); > return; > } > /* --END ERROR HANDLING-- */ > > #ifdef HAVE_STATUS_SET_BYTES > MPIR_Status_set_bytes(status, datatype, err); > #endif > > *error_code = MPI_SUCCESS; > } > > > > #define ADIOI_BUFFERED_READ \ > { \ > if (req_off >= readbuf_off + readbuf_len) { \ > readbuf_off = req_off; \ > readbuf_len = (int) (ADIOI_MIN(max_bufsize, end_offset-readbuf_off+1));\ > lseek(fd->fd_sys, readbuf_off, SEEK_SET);\ > if (!(fd->atomicity)) ADIOI_READ_LOCK(fd, readbuf_off, SEEK_SET, readbuf_len);\ > err = read(fd->fd_sys, readbuf, readbuf_len);\ > if (!(fd->atomicity)) ADIOI_UNLOCK(fd, readbuf_off, SEEK_SET, readbuf_len);\ > if (err == -1) err_flag = 1; \ > } \ > while (req_len > readbuf_off + readbuf_len - req_off) { \ > partial_read = (int) (readbuf_off + readbuf_len - req_off); \ > tmp_buf = (char *) ADIOI_Malloc(partial_read); \ > memcpy(tmp_buf, readbuf+readbuf_len-partial_read, partial_read); \ > ADIOI_Free(readbuf); \ > readbuf = (char *) ADIOI_Malloc(partial_read + max_bufsize); \ > memcpy(readbuf, tmp_buf, partial_read); \ > ADIOI_Free(tmp_buf); \ > readbuf_off += readbuf_len-partial_read; \ > readbuf_len = (int) (partial_read + ADIOI_MIN(max_bufsize, \ > end_offset-readbuf_off+1)); \ > lseek(fd->fd_sys, readbuf_off+partial_read, SEEK_SET);\ > if (!(fd->atomicity)) ADIOI_READ_LOCK(fd, readbuf_off+partial_read, SEEK_SET, readbuf_len-partial_read);\ > err = read(fd->fd_sys, readbuf+partial_read, readbuf_len-partial_read);\ > if (!(fd->atomicity)) ADIOI_UNLOCK(fd, readbuf_off+partial_read, SEEK_SET, readbuf_len-partial_read);\ > if (err == -1) err_flag = 1; \ > } \ > memcpy((char *)buf + userbuf_off, readbuf+req_off-readbuf_off, req_len); \ > } > > > void ADIOI_BGL_ReadStrided(ADIO_File fd, void *buf, int count, > MPI_Datatype datatype, int file_ptr_type, > ADIO_Offset offset, ADIO_Status *status, int > *error_code) > { > /* offset is in units of etype relative to the filetype. */ > > ADIOI_Flatlist_node *flat_buf, *flat_file; > int i, j, k, err=-1, brd_size, frd_size=0, st_index=0; > int bufsize, num, size, sum, n_etypes_in_filetype, size_in_filetype; > int n_filetypes, etype_in_filetype; > ADIO_Offset abs_off_in_filetype=0; > int filetype_size, etype_size, buftype_size, req_len, partial_read; > MPI_Aint filetype_extent, buftype_extent; > int buf_count, buftype_is_contig, filetype_is_contig; > ADIO_Offset userbuf_off; > ADIO_Offset off, req_off, disp, end_offset=0, readbuf_off, start_off; > char *readbuf, *tmp_buf, *value; > int flag, st_frd_size, st_n_filetypes, readbuf_len; > int new_brd_size, new_frd_size, err_flag=0, info_flag, max_bufsize; > > static char myname[] = "ADIOI_BGL_READSTRIDED"; > > if (fd->hints->ds_read == ADIOI_HINT_DISABLE) { > /* if user has disabled data sieving on reads, use naive > * approach instead. > */ > /*FPRINTF(stderr, "ADIOI_GEN_ReadStrided_naive(%d):\n", __LINE__);*/ > ADIOI_GEN_ReadStrided_naive(fd, > buf, > count, > datatype, > file_ptr_type, > offset, > status, > error_code); > return; > } > /*FPRINTF(stderr, "%s(%d):\n",myname, __LINE__);*/ > > ADIOI_Datatype_iscontig(datatype, &buftype_is_contig); > ADIOI_Datatype_iscontig(fd->filetype, &filetype_is_contig); > > MPI_Type_size(fd->filetype, &filetype_size); > if ( ! filetype_size ) { > *error_code = MPI_SUCCESS; > return; > } > > MPI_Type_extent(fd->filetype, &filetype_extent); > MPI_Type_size(datatype, &buftype_size); > MPI_Type_extent(datatype, &buftype_extent); > etype_size = fd->etype_size; > > bufsize = buftype_size * count; > > /* get max_bufsize from the info object. */ > > value = (char *) ADIOI_Malloc((MPI_MAX_INFO_VAL+1)*sizeof(char)); > MPI_Info_get(fd->info, "ind_rd_buffer_size", MPI_MAX_INFO_VAL, value, > &info_flag); > max_bufsize = atoi(value); > ADIOI_Free(value); > > if (!buftype_is_contig && filetype_is_contig) { > > /* noncontiguous in memory, contiguous in file. */ > > ADIOI_Flatten_datatype(datatype); > flat_buf = ADIOI_Flatlist; > while (flat_buf->type != datatype) flat_buf = flat_buf->next; > > off = (file_ptr_type == ADIO_INDIVIDUAL) ? fd->fp_ind : > fd->disp + etype_size * offset; > > start_off = off; > end_offset = off + bufsize - 1; > readbuf_off = off; > readbuf = (char *) ADIOI_Malloc(max_bufsize); > readbuf_len = (int) (ADIOI_MIN(max_bufsize, end_offset-readbuf_off+1)); > > /* if atomicity is true, lock (exclusive) the region to be accessed */ > if (fd->atomicity) > ADIOI_WRITE_LOCK(fd, start_off, SEEK_SET, end_offset-start_off+1); > > lseek(fd->fd_sys, readbuf_off, SEEK_SET); > if (!(fd->atomicity)) ADIOI_READ_LOCK(fd, readbuf_off, SEEK_SET, readbuf_len); > err = read(fd->fd_sys, readbuf, readbuf_len); > if (!(fd->atomicity)) ADIOI_UNLOCK(fd, readbuf_off, SEEK_SET, readbuf_len); > if (err == -1) err_flag = 1; > > for (j=0; j for (i=0; icount; i++) { > userbuf_off = j*buftype_extent + flat_buf->indices[i]; > req_off = off; > req_len = flat_buf->blocklens[i]; > ADIOI_BUFFERED_READ > off += flat_buf->blocklens[i]; > } > > if (fd->atomicity) > ADIOI_UNLOCK(fd, start_off, SEEK_SET, end_offset-start_off+1); > > if (file_ptr_type == ADIO_INDIVIDUAL) fd->fp_ind = off; > > ADIOI_Free(readbuf); /* malloced in the buffered_read macro */ > > if (err_flag) { > *error_code = MPIO_Err_create_code(MPI_SUCCESS, > MPIR_ERR_RECOVERABLE, myname, > __LINE__, MPI_ERR_IO, "**io", > "**io %s", strerror(errno)); > } > else *error_code = MPI_SUCCESS; > } > > else { /* noncontiguous in file */ > > /* filetype already flattened in ADIO_Open */ > flat_file = ADIOI_Flatlist; > while (flat_file->type != fd->filetype) flat_file = flat_file->next; > disp = fd->disp; > > if (file_ptr_type == ADIO_INDIVIDUAL) { > offset = fd->fp_ind; /* in bytes */ > n_filetypes = -1; > flag = 0; > while (!flag) { > n_filetypes++; > for (i=0; icount; i++) { > if (disp + flat_file->indices[i] + > (ADIO_Offset) n_filetypes*filetype_extent + flat_file->blocklens[i] > >= offset) { > st_index = i; > frd_size = (int) (disp + flat_file->indices[i] + > (ADIO_Offset) n_filetypes*filetype_extent > + flat_file->blocklens[i] - offset); > flag = 1; > break; > } > } > } > } > else { > n_etypes_in_filetype = filetype_size/etype_size; > n_filetypes = (int) (offset / n_etypes_in_filetype); > etype_in_filetype = (int) (offset % n_etypes_in_filetype); > size_in_filetype = etype_in_filetype * etype_size; > > sum = 0; > for (i=0; icount; i++) { > sum += flat_file->blocklens[i]; > if (sum > size_in_filetype) { > st_index = i; > frd_size = sum - size_in_filetype; > abs_off_in_filetype = flat_file->indices[i] + > size_in_filetype - (sum - flat_file->blocklens[i]); > break; > } > } > > /* abs. offset in bytes in the file */ > offset = disp + (ADIO_Offset) n_filetypes*filetype_extent + abs_off_in_filetype; > } > > start_off = offset; > > /* Calculate end_offset, the last byte-offset that will be accessed. > e.g., if start_offset=0 and 100 bytes to be read, end_offset=99*/ > > st_frd_size = frd_size; > st_n_filetypes = n_filetypes; > i = 0; > j = st_index; > off = offset; > frd_size = ADIOI_MIN(st_frd_size, bufsize); > while (i < bufsize) { > i += frd_size; > end_offset = off + frd_size - 1; > > if (j < (flat_file->count - 1)) j++; > else { > j = 0; > n_filetypes++; > } > > off = disp + flat_file->indices[j] + (ADIO_Offset) n_filetypes*filetype_extent; > frd_size = ADIOI_MIN(flat_file->blocklens[j], bufsize-i); > } > > /* if atomicity is true, lock (exclusive) the region to be accessed */ > if (fd->atomicity) > ADIOI_WRITE_LOCK(fd, start_off, SEEK_SET, end_offset-start_off+1); > > /* initial read into readbuf */ > readbuf_off = offset; > readbuf = (char *) ADIOI_Malloc(max_bufsize); > readbuf_len = (int) (ADIOI_MIN(max_bufsize, end_offset-readbuf_off+1)); > > lseek(fd->fd_sys, offset, SEEK_SET); > if (!(fd->atomicity)) ADIOI_READ_LOCK(fd, offset, SEEK_SET, readbuf_len); > err = read(fd->fd_sys, readbuf, readbuf_len); > if (!(fd->atomicity)) ADIOI_UNLOCK(fd, offset, SEEK_SET, readbuf_len); > > if (err == -1) err_flag = 1; > > if (buftype_is_contig && !filetype_is_contig) { > > /* contiguous in memory, noncontiguous in file. should be the most > common case. */ > > i = 0; > j = st_index; > off = offset; > n_filetypes = st_n_filetypes; > frd_size = ADIOI_MIN(st_frd_size, bufsize); > while (i < bufsize) { > if (frd_size) { > /* TYPE_UB and TYPE_LB can result in > frd_size = 0. save system call in such cases */ > /* lseek(fd->fd_sys, off, SEEK_SET); > err = read(fd->fd_sys, ((char *) buf) + i, frd_size);*/ > > req_off = off; > req_len = frd_size; > userbuf_off = i; > ADIOI_BUFFERED_READ > } > i += frd_size; > > if (off + frd_size < disp + flat_file->indices[j] + > flat_file->blocklens[j] + (ADIO_Offset) n_filetypes*filetype_extent) > off += frd_size; > /* did not reach end of contiguous block in filetype. > no more I/O needed. off is incremented by frd_size. */ > else { > if (j < (flat_file->count - 1)) j++; > else { > j = 0; > n_filetypes++; > } > off = disp + flat_file->indices[j] + > (ADIO_Offset) n_filetypes*filetype_extent; > frd_size = ADIOI_MIN(flat_file->blocklens[j], bufsize-i); > } > } > } > else { > /* noncontiguous in memory as well as in file */ > > ADIOI_Flatten_datatype(datatype); > flat_buf = ADIOI_Flatlist; > while (flat_buf->type != datatype) flat_buf = flat_buf->next; > > k = num = buf_count = 0; > i = (int) (flat_buf->indices[0]); > j = st_index; > off = offset; > n_filetypes = st_n_filetypes; > frd_size = st_frd_size; > brd_size = flat_buf->blocklens[0]; > > while (num < bufsize) { > size = ADIOI_MIN(frd_size, brd_size); > if (size) { > /* lseek(fd->fd_sys, off, SEEK_SET); > err = read(fd->fd_sys, ((char *) buf) + i, size); */ > > req_off = off; > req_len = size; > userbuf_off = i; > ADIOI_BUFFERED_READ > } > > new_frd_size = frd_size; > new_brd_size = brd_size; > > if (size == frd_size) { > /* reached end of contiguous block in file */ > if (j < (flat_file->count - 1)) j++; > else { > j = 0; > n_filetypes++; > } > > off = disp + flat_file->indices[j] + > (ADIO_Offset) n_filetypes*filetype_extent; > > new_frd_size = flat_file->blocklens[j]; > if (size != brd_size) { > i += size; > new_brd_size -= size; > } > } > > if (size == brd_size) { > /* reached end of contiguous block in memory */ > > k = (k + 1)%flat_buf->count; > buf_count++; > i = (int) (buftype_extent*(buf_count/flat_buf->count) + > flat_buf->indices[k]); > new_brd_size = flat_buf->blocklens[k]; > if (size != frd_size) { > off += size; > new_frd_size -= size; > } > } > num += size; > frd_size = new_frd_size; > brd_size = new_brd_size; > } > } > > if (fd->atomicity) > ADIOI_UNLOCK(fd, start_off, SEEK_SET, end_offset-start_off+1); > > if (file_ptr_type == ADIO_INDIVIDUAL) fd->fp_ind = off; > > ADIOI_Free(readbuf); /* malloced in the buffered_read macro */ > > if (err_flag) { > *error_code = MPIO_Err_create_code(MPI_SUCCESS, > MPIR_ERR_RECOVERABLE, myname, > __LINE__, MPI_ERR_IO, "**io", > "**io %s", strerror(errno)); > } > else *error_code = MPI_SUCCESS; > } > > fd->fp_sys_posn = -1; /* set it to null. */ > > #ifdef HAVE_STATUS_SET_BYTES > MPIR_Status_set_bytes(status, datatype, bufsize); > /* This is a temporary way of filling in status. The right way is to > keep track of how much data was actually read and placed in buf > by ADIOI_BUFFERED_READ. */ > #endif > > if (!buftype_is_contig) ADIOI_Delete_flattened(datatype); > } diff -rN mpich2-1.0.7rc1/src/mpi/romio/adio/ad_bgl/ad_bgl_setsh.c bgp-mpich2/src/mpi/romio/adio/ad_bgl/ad_bgl_setsh.c 0a1,73 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file ad_bgl_setsh.c > * \brief ??? > */ > > /* -*- Mode: C; c-basic-offset:4 ; -*- */ > /* > * Copyright (C) 1997 University of Chicago. > * See COPYRIGHT notice in top-level directory. > */ > > #include "ad_bgl.h" > > /* set the shared file pointer to "offset" etypes relative to the current > view */ > > /* > This looks very similar to ADIOI_GEN_Set_shared_fp, except this > function avoids locking the file twice. The generic version does > > Write lock > ADIO_WriteContig > Unlock > > For BGL, ADIOI_BGL_WriteContig does a lock before writing to disable > caching. To avoid the lock being called twice, this version for BGL does > > Write lock > Lseek > Write > Unlock > > */ > > void ADIOI_BGL_Set_shared_fp(ADIO_File fd, ADIO_Offset offset, int *error_code) > { > int err; > MPI_Comm dupcommself; > static char myname[] = "ADIOI_BGL_SET_SHARED_FP"; > > if (fd->shared_fp_fd == ADIO_FILE_NULL) { > MPI_Comm_dup(MPI_COMM_SELF, &dupcommself); > fd->shared_fp_fd = ADIO_Open(MPI_COMM_SELF, dupcommself, > fd->shared_fp_fname, > fd->file_system, fd->fns, > ADIO_CREATE | ADIO_RDWR | ADIO_DELETE_ON_CLOSE, > 0, MPI_BYTE, MPI_BYTE, MPI_INFO_NULL, > ADIO_PERM_NULL, error_code); > } > > if (*error_code != MPI_SUCCESS) return; > > ADIOI_WRITE_LOCK(fd->shared_fp_fd, 0, SEEK_SET, sizeof(ADIO_Offset)); > lseek(fd->shared_fp_fd->fd_sys, 0, SEEK_SET); > err = write(fd->shared_fp_fd->fd_sys, &offset, sizeof(ADIO_Offset)); > ADIOI_UNLOCK(fd->shared_fp_fd, 0, SEEK_SET, sizeof(ADIO_Offset)); > > if (err == -1) { > *error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, > myname, __LINE__, MPI_ERR_IO, > "**io", > "**io %s", strerror(errno)); > } > else *error_code = MPI_SUCCESS; > } diff -rN mpich2-1.0.7rc1/src/mpi/romio/adio/ad_bgl/ad_bgl_tuning.c bgp-mpich2/src/mpi/romio/adio/ad_bgl/ad_bgl_tuning.c 0a1,109 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file ad_bgl_tuning.c > * \brief ??? > */ > > /*--------------------------------------------------------------------- > * ad_bgl_tuning.c > * > * defines global variables and functions for performance tuning and > * functional debugging. > *---------------------------------------------------------------------*/ > > #include "ad_bgl_tuning.h" > #include "mpi.h" > > int bglmpio_timing; > int bglmpio_timing2; > int bglmpio_comm; > int bglmpio_tunegather; > int bglmpio_tuneblocking; > > double bglmpio_prof_cw [BGLMPIO_CIO_LAST]; > double bglmpio_prof_cr [BGLMPIO_CIO_LAST]; > > /* set internal variables for tuning environment variables */ > void ad_bgl_get_env_vars() { > char *x; > > bglmpio_comm = 0; > x = getenv( "BGLMPIO_COMM" ); > if (x) bglmpio_comm = atoi(x); > bglmpio_timing = 0; > x = getenv( "BGLMPIO_TIMING" ); > if (x) bglmpio_timing = atoi(x); > bglmpio_timing2 = 0; > x = getenv( "BGLMPIO_TIMING2" ); > if (x) bglmpio_timing2 = atoi(x); > bglmpio_tunegather = 1; > x = getenv( "BGLMPIO_TUNEGATHER" ); > if (x) bglmpio_tunegather = atoi(x); > bglmpio_tuneblocking = 1; > x = getenv( "BGLMPIO_TUNEBLOCKING" ); > if (x) bglmpio_tuneblocking = atoi(x); > } > > /* report timing breakdown for MPI I/O collective call */ > void ad_bgl_wr_timing_report( int rw, ADIO_File fd, int myrank, int nprocs ) > { > int i; > > if (bglmpio_timing) { > > double *bglmpio_prof_org = bglmpio_prof_cr; > if (rw) bglmpio_prof_org = bglmpio_prof_cw; > > double bglmpio_prof_avg[ BGLMPIO_CIO_LAST ]; > double bglmpio_prof_max[ BGLMPIO_CIO_LAST ]; > > MPI_Reduce( bglmpio_prof_org, bglmpio_prof_avg, BGLMPIO_CIO_LAST, MPI_DOUBLE, MPI_SUM, 0, fd->comm ); > MPI_Reduce( bglmpio_prof_org, bglmpio_prof_max, BGLMPIO_CIO_LAST, MPI_DOUBLE, MPI_MAX, 0, fd->comm ); > > if (myrank == 0) { > > for (i=0; i > if (bglmpio_timing2) { > bglmpio_prof_avg[ BGLMPIO_CIO_B_POSI_RW ] = bglmpio_prof_avg[ BGLMPIO_CIO_DATA_SIZE ] * nprocs / > bglmpio_prof_max[ BGLMPIO_CIO_T_POSI_RW ]; > bglmpio_prof_avg[ BGLMPIO_CIO_B_MPIO_RW ] = bglmpio_prof_avg[ BGLMPIO_CIO_DATA_SIZE ] * nprocs / > bglmpio_prof_max[ BGLMPIO_CIO_T_MPIO_RW ]; > } else { > > bglmpio_prof_avg[ BGLMPIO_CIO_B_POSI_RW ] = 0; > bglmpio_prof_avg[ BGLMPIO_CIO_B_MPIO_RW ] = 0; > } > > bglmpio_prof_avg[ BGLMPIO_CIO_B_MPIO_CRW ] = bglmpio_prof_avg[ BGLMPIO_CIO_DATA_SIZE ] * nprocs / > bglmpio_prof_max[ BGLMPIO_CIO_T_MPIO_CRW ]; > > printf("\tTIMING-1 %1s , ", (rw ? "W" : "R") ); > printf( "SZ: %12.4f , ", bglmpio_prof_avg[ BGLMPIO_CIO_DATA_SIZE ] * nprocs ); > printf( "SK-a: %10.3f , ", bglmpio_prof_avg[ BGLMPIO_CIO_T_SEEK ] ); > printf( "SK-m: %10.3f , ", bglmpio_prof_max[ BGLMPIO_CIO_T_SEEK ] ); > printf( "LC-a: %10.3f , ", bglmpio_prof_avg[ BGLMPIO_CIO_T_LCOMP ] ); > printf( "GA-m: %10.3f , ", bglmpio_prof_max[ BGLMPIO_CIO_T_GATHER ] ); > printf( "AN-a: %10.3f , ", bglmpio_prof_avg[ BGLMPIO_CIO_T_PATANA ] ); > printf( "FD-a: %10.3f , ", bglmpio_prof_avg[ BGLMPIO_CIO_T_FD_PART ] ); > printf( "MY-a: %10.3f , ", bglmpio_prof_avg[ BGLMPIO_CIO_T_MYREQ ] ); > printf( "OT-m: %10.3f , ", bglmpio_prof_max[ BGLMPIO_CIO_T_OTHREQ ] ); > printf( "EX-m: %10.3f , ", bglmpio_prof_max[ BGLMPIO_CIO_T_DEXCH ] ); > printf("\tTIMING-2 %1s , ", (rw ? "W" : "R") ); > printf( "PXT-m: %10.3f , ", bglmpio_prof_avg[ BGLMPIO_CIO_T_POSI_RW ] ); > printf( "MPT-m: %10.3f , ", bglmpio_prof_avg[ BGLMPIO_CIO_T_MPIO_RW ] ); > printf("MPTC-m: %10.3f , ", bglmpio_prof_avg[ BGLMPIO_CIO_T_MPIO_CRW ] ); > printf( "PXB: %10.3f , ", bglmpio_prof_avg[ BGLMPIO_CIO_B_POSI_RW ] ); > printf( "MPB: %10.3f , ", bglmpio_prof_avg[ BGLMPIO_CIO_B_MPIO_RW ] ); > printf( "MPBC: %10.3f , ", bglmpio_prof_avg[ BGLMPIO_CIO_B_MPIO_CRW ] ); > } > } > > } diff -rN mpich2-1.0.7rc1/src/mpi/romio/adio/ad_bgl/ad_bgl_tuning.h bgp-mpich2/src/mpi/romio/adio/ad_bgl/ad_bgl_tuning.h 0a1,99 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file ad_bgl_tuning.h > * \brief ??? > */ > > /*--------------------------------------------------------------------- > * ad_bgl_tuning.h > * > * declares global variables and macros for performance tuning and > * functional debugging. > *---------------------------------------------------------------------*/ > > #ifndef AD_BGL_TUNING_H_ > #define AD_BGL_TUNING_H_ > > #include "adio.h" > > #define AD_BGL_assert( a ) if (!(a)) { \ > fprintf( stderr, "AD_BGL_assert, file=%s, line=%d\n", __FILE__, __LINE__ ); \ > MPI_Abort( MPI_COMM_WORLD, 1 ); \ > } > > /*----------------------------------------- > * Global variables for the control of > * 1. timing > * 2. select specific optimizations > *-----------------------------------------*/ > > /* timing fields */ > enum { > BGLMPIO_CIO_DATA_SIZE=0, > BGLMPIO_CIO_T_SEEK, > BGLMPIO_CIO_T_LCOMP, /* time for ADIOI_Calc_my_off_len(), local */ > BGLMPIO_CIO_T_GATHER, /* time for previous MPI_Allgather, now Allreduce */ > BGLMPIO_CIO_T_PATANA, /* time for a quick test if access is contiguous or not, local */ > BGLMPIO_CIO_T_FD_PART, /* time for file domain partitioning, local */ > BGLMPIO_CIO_T_MYREQ, /* time for ADIOI_BGL_Calc_my_req(), local */ > BGLMPIO_CIO_T_OTHREQ, /* time for ADIOI_Calc_others_req(), short Alltoall */ > BGLMPIO_CIO_T_DEXCH, /* time for I/O data exchange */ > BGLMPIO_CIO_T_POSI_RW, > BGLMPIO_CIO_B_POSI_RW, > BGLMPIO_CIO_T_MPIO_RW, /* time for ADIOI_BGL_WriteContig() */ > BGLMPIO_CIO_B_MPIO_RW, > BGLMPIO_CIO_T_MPIO_CRW, /* time for ADIOI_BGL_WriteStridedColl() */ > BGLMPIO_CIO_B_MPIO_CRW, > BGLMPIO_CIO_LAST > }; > > extern double bglmpio_prof_cw [BGLMPIO_CIO_LAST]; > extern double bglmpio_prof_cr [BGLMPIO_CIO_LAST]; > > > /* corresponds to environment variables to select optimizations and timing level */ > extern int bglmpio_timing; > extern int bglmpio_timing2; > extern int bglmpio_comm; > extern int bglmpio_tunegather; > extern int bglmpio_tuneblocking; > > > /* set internal variables for tuning environment variables */ > void ad_bgl_get_env_vars(); > > /* report timing breakdown for MPI I/O collective call */ > void ad_bgl_timing_crw_report( int rw, ADIO_File fd, int myrank, int nprocs ); > > /* note: > * T := timing; > * CIO := collective I/O > */ > #define BGLMPIO_T_CIO_RESET( LEVEL, RW ) \ > if (bglmpio_timing_cw_level >= LEVEL) { \ > int i; \ > for ( i = 0; i < BGLMPIO_T_LAST; i ++ ) \ > bglmpio_prof_c##RW [ i ] = 0; \ > } > > #define BGLMPIO_T_CIO_REPORT( LEVEL, RW, FD, MYRANK, NPROCS ) \ > if (bglmpio_timing_cw_level >= LEVEL) { \ > ad_bgl_timing_crw_report ( RW, FD, MYRANK, NPROCS ); \ > } > > #define BGLMPIO_T_CIO_SET_GET( LEVEL, RW, DOBAR, ISSET, ISGET, VAR1, VAR2 ) \ > if (bglmpio_timing_cw_level >= LEVEL) { \ > if ( DOBAR ) MPI_Barrier( fd->comm ); \ > double temp = MPI_Wtime(); \ > if ( ISSET ) bglmpio_prof_c##RW [ VAR1 ] = temp; \ > if ( ISGET ) bglmpio_prof_c##RW [ VAR2 ] = temp - bglmpio_prof_c##RW [ VAR2 ] ; \ > } > > #endif /* AD_BGL_TUNING_H_ */ diff -rN mpich2-1.0.7rc1/src/mpi/romio/adio/ad_bgl/ad_bgl_wrcoll.c bgp-mpich2/src/mpi/romio/adio/ad_bgl/ad_bgl_wrcoll.c 0a1,1456 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file ad_bgl_wrcoll.c > * \brief ??? > */ > > /* -*- Mode: C; c-basic-offset:4 ; -*- */ > /* > * Copyright (C) 1997 University of Chicago. > * See COPYRIGHT notice in top-level directory. > */ > > #include "adio.h" > #include "adio_extern.h" > #include "ad_bgl.h" > #include "ad_bgl_pset.h" > #include "ad_bgl_aggrs.h" > > #ifdef PROFILE > #include "mpe.h" > #endif > > /* prototypes of functions used for collective writes only. */ > static void ADIOI_Exch_and_write(ADIO_File fd, void *buf, MPI_Datatype > datatype, int nprocs, int myrank, ADIOI_Access > *others_req, ADIO_Offset *offset_list, > int *len_list, int contig_access_count, ADIO_Offset > min_st_offset, ADIO_Offset fd_size, > ADIO_Offset *fd_start, ADIO_Offset *fd_end, > int *buf_idx, int *error_code); > static void ADIOI_W_Exchange_data(ADIO_File fd, void *buf, char *write_buf, > ADIOI_Flatlist_node *flat_buf, ADIO_Offset > *offset_list, int *len_list, int *send_size, > int *recv_size, ADIO_Offset off, int size, > int *count, int *start_pos, int *partial_recv, > int *sent_to_proc, int nprocs, > int myrank, int > buftype_is_contig, int contig_access_count, > ADIO_Offset min_st_offset, ADIO_Offset fd_size, > ADIO_Offset *fd_start, ADIO_Offset *fd_end, > ADIOI_Access *others_req, > int *send_buf_idx, int *curr_to_proc, > int *done_to_proc, int *hole, int iter, > MPI_Aint buftype_extent, int *buf_idx, int *error_code); > static void ADIOI_W_Exchange_data_alltoallv( > ADIO_File fd, void *buf, > char *write_buf, /* 1 */ > ADIOI_Flatlist_node *flat_buf, > ADIO_Offset *offset_list, > int *len_list, int *send_size, int *recv_size, > ADIO_Offset off, int size, /* 2 */ > int *count, int *start_pos, int *partial_recv, > int *sent_to_proc, int nprocs, int myrank, > int buftype_is_contig, int contig_access_count, > ADIO_Offset min_st_offset, > ADIO_Offset fd_size, > ADIO_Offset *fd_start, > ADIO_Offset *fd_end, > ADIOI_Access *others_req, > int *send_buf_idx, int *curr_to_proc, /* 3 */ > int *done_to_proc, int *hole, /* 4 */ > int iter, MPI_Aint buftype_extent, int *buf_idx, > int *error_code); > static void ADIOI_Fill_send_buffer(ADIO_File fd, void *buf, ADIOI_Flatlist_node > *flat_buf, char **send_buf, ADIO_Offset > *offset_list, int *len_list, int *send_size, > MPI_Request *requests, int *sent_to_proc, > int nprocs, int myrank, > int contig_access_count, ADIO_Offset > min_st_offset, ADIO_Offset fd_size, > ADIO_Offset *fd_start, ADIO_Offset *fd_end, > int *send_buf_idx, int *curr_to_proc, > int *done_to_proc, int iter, > MPI_Aint buftype_extent); > static void ADIOI_Fill_send_buffer_nosend(ADIO_File fd, void *buf, ADIOI_Flatlist_node > *flat_buf, char **send_buf, ADIO_Offset > *offset_list, int *len_list, int *send_size, > MPI_Request *requests, int *sent_to_proc, > int nprocs, int myrank, > int contig_access_count, ADIO_Offset > min_st_offset, ADIO_Offset fd_size, > ADIO_Offset *fd_start, ADIO_Offset *fd_end, > int *send_buf_idx, int *curr_to_proc, > int *done_to_proc, int iter, > MPI_Aint buftype_extent); > static void ADIOI_Heap_merge(ADIOI_Access *others_req, int *count, > ADIO_Offset *srt_off, int *srt_len, int *start_pos, > int nprocs, int nprocs_recv, int total_elements); > > > void ADIOI_BGL_WriteStridedColl(ADIO_File fd, void *buf, int count, > MPI_Datatype datatype, int file_ptr_type, > ADIO_Offset offset, ADIO_Status *status, int > *error_code) > { > /* Uses a generalized version of the extended two-phase method described > in "An Extended Two-Phase Method for Accessing Sections of > Out-of-Core Arrays", Rajeev Thakur and Alok Choudhary, > Scientific Programming, (5)4:301--317, Winter 1996. > http://www.mcs.anl.gov/home/thakur/ext2ph.ps */ > > ADIOI_Access *my_req; > /* array of nprocs access structures, one for each other process in > whose file domain this process's request lies */ > > ADIOI_Access *others_req; > /* array of nprocs access structures, one for each other process > whose request lies in this process's file domain. */ > > int i, filetype_is_contig, nprocs, nprocs_for_coll, myrank; > int contig_access_count=0, interleave_count = 0, buftype_is_contig; > int *count_my_req_per_proc, count_my_req_procs, count_others_req_procs; > ADIO_Offset orig_fp, start_offset, end_offset, fd_size, min_st_offset, off; > ADIO_Offset *offset_list = NULL, *st_offsets = NULL, *fd_start = NULL, > *fd_end = NULL, *end_offsets = NULL; > ADIO_Offset *bgl_offsets0 = NULL, *bgl_offsets = NULL; > int ii; > > int *buf_idx = NULL, *len_list = NULL; > > double io_time = 0, all_time, max_all_time; > double tstep1, max_tstep1; > double tstep1_1, max_tstep1_1; > double tstep1_2, max_tstep1_2; > double tstep1_3, max_tstep1_3; > double tstep2, max_tstep2; > double tstep3, max_tstep3; > double tstep4, max_tstep4; > double sum_sz; > > #if BGL_PROFILE > BGLMPIO_T_CIO_RESET( 0, w ) > #endif > > #ifdef PROFILE > MPE_Log_event(13, 0, "start computation"); > #endif > > MPI_Comm_size(fd->comm, &nprocs); > MPI_Comm_rank(fd->comm, &myrank); > > /* the number of processes that actually perform I/O, nprocs_for_coll, > * is stored in the hints off the ADIO_File structure > */ > nprocs_for_coll = fd->hints->cb_nodes; > orig_fp = fd->fp_ind; > > #if BGL_PROFILE > BGLMPIO_T_CIO_SET_GET( 0, w, 0, 1, 0, BGLMPIO_CIO_LCOMP, BGLMPIO_CIO_LAST ) > #endif > > > /* only check for interleaving if cb_write isn't disabled */ > if (fd->hints->cb_write != ADIOI_HINT_DISABLE) { > /* For this process's request, calculate the list of offsets and > lengths in the file and determine the start and end offsets. */ > > /* Note: end_offset points to the last byte-offset that will be accessed. > e.g., if start_offset=0 and 100 bytes to be read, end_offset=99*/ > > ADIOI_Calc_my_off_len(fd, count, datatype, file_ptr_type, offset, > &offset_list, &len_list, &start_offset, > &end_offset, &contig_access_count); > > #if BGL_PROFILE > BGLMPIO_T_CIO_SET_GET( 0, w, 1, 1, 1, BGLMPIO_CIO_GATHER, BGLMPIO_CIO_LCOMP ) > #endif > > /* each process communicates its start and end offsets to other > processes. The result is an array each of start and end offsets stored > in order of process rank. */ > > st_offsets = (ADIO_Offset *) ADIOI_Malloc(nprocs*sizeof(ADIO_Offset)); > end_offsets = (ADIO_Offset *) ADIOI_Malloc(nprocs*sizeof(ADIO_Offset)); > > if (bglmpio_tunegather) { > bgl_offsets0 = (ADIO_Offset *) ADIOI_Malloc(2*nprocs*sizeof(ADIO_Offset)); > bgl_offsets = (ADIO_Offset *) ADIOI_Malloc(2*nprocs*sizeof(ADIO_Offset)); > for (ii=0; ii bgl_offsets0[ii*2] = 0; > bgl_offsets0[ii*2+1] = 0; > } > bgl_offsets0[myrank*2] = start_offset; > bgl_offsets0[myrank*2+1] = end_offset; > > MPI_Allreduce( bgl_offsets0, bgl_offsets, nprocs*2, ADIO_OFFSET, MPI_MAX, fd->comm ); > > for (ii=0; ii st_offsets [ii] = bgl_offsets[ii*2] ; > end_offsets[ii] = bgl_offsets[ii*2+1]; > } > ADIOI_Free( bgl_offsets0 ); > ADIOI_Free( bgl_offsets ); > } else { > MPI_Allgather(&start_offset, 1, ADIO_OFFSET, st_offsets, 1, > ADIO_OFFSET, fd->comm); > MPI_Allgather(&end_offset, 1, ADIO_OFFSET, end_offsets, 1, > ADIO_OFFSET, fd->comm); > } > > #if BGL_PROFILE > BGLMPIO_T_CIO_SET_GET( 0, w, 0, 1, 1, BGLMPIO_CIO_PATANA, BGLMPIO_CIO_GATHER ) > #endif > > /* are the accesses of different processes interleaved? */ > for (i=1; i if ((st_offsets[i] < end_offsets[i-1]) && > (st_offsets[i] <= end_offsets[i])) interleave_count++; > /* This is a rudimentary check for interleaving, but should suffice > for the moment. */ > } > > ADIOI_Datatype_iscontig(datatype, &buftype_is_contig); > > if (fd->hints->cb_write == ADIOI_HINT_DISABLE || > (!interleave_count && (fd->hints->cb_write == ADIOI_HINT_AUTO))) > { > /* use independent accesses */ > if (fd->hints->cb_write != ADIOI_HINT_DISABLE) { > ADIOI_Free(offset_list); > ADIOI_Free(len_list); > ADIOI_Free(st_offsets); > ADIOI_Free(end_offsets); > } > > fd->fp_ind = orig_fp; > ADIOI_Datatype_iscontig(fd->filetype, &filetype_is_contig); > > if (buftype_is_contig && filetype_is_contig) { > > if (file_ptr_type == ADIO_EXPLICIT_OFFSET) { > off = fd->disp + (fd->etype_size) * offset; > ADIO_WriteContig(fd, buf, count, datatype, > ADIO_EXPLICIT_OFFSET, > off, status, error_code); > } > else ADIO_WriteContig(fd, buf, count, datatype, ADIO_INDIVIDUAL, > 0, status, error_code); > } > else ADIO_WriteStrided(fd, buf, count, datatype, file_ptr_type, > offset, status, error_code); > > return; > } > > #if BGL_PROFILE > BGLMPIO_T_CIO_SET_GET( 0, w, 1, 1, 1, BGLMPIO_CIO_FD_PART, BGLMPIO_CIO_PATANA ) > #endif > > /* Divide the I/O workload among "nprocs_for_coll" processes. This is > done by (logically) dividing the file into file domains (FDs); each > process may directly access only its own file domain. */ > > if (bglmpio_tuneblocking) > ADIOI_BGL_GPFS_Calc_file_domains(st_offsets, end_offsets, nprocs, > nprocs_for_coll, &min_st_offset, > &fd_start, &fd_end, &fd_size, fd->fs_ptr); > else > ADIOI_Calc_file_domains(st_offsets, end_offsets, nprocs, > nprocs_for_coll, &min_st_offset, > &fd_start, &fd_end, &fd_size); > > #if BGL_PROFILE > BGLMPIO_T_CIO_SET_GET( 0, w, 0, 1, 1, BGLMPIO_CIO_MYREQ, BGLMPIO_CIO_FD_PART ) > #endif > > /* calculate what portions of the access requests of this process are > located in what file domains */ > > if (bglmpio_tuneblocking) > ADIOI_BGL_Calc_my_req(fd, offset_list, len_list, contig_access_count, > min_st_offset, fd_start, fd_end, fd_size, > nprocs, &count_my_req_procs, > &count_my_req_per_proc, &my_req, > &buf_idx); > else > ADIOI_Calc_my_req(fd, offset_list, len_list, contig_access_count, > min_st_offset, fd_start, fd_end, fd_size, > nprocs, &count_my_req_procs, > &count_my_req_per_proc, &my_req, > &buf_idx); > > #if BGL_PROFILE > BGLMPIO_T_CIO_SET_GET( 0, w, 1, 1, 1, BGLMPIO_CIO_OTHREQ, BGLMPIO_CIO_MYREQ ) > #endif > > /* based on everyone's my_req, calculate what requests of other > processes lie in this process's file domain. > count_others_req_procs = number of processes whose requests lie in > this process's file domain (including this process itself) > count_others_req_per_proc[i] indicates how many separate contiguous > requests of proc. i lie in this process's file domain. */ > > if (bglmpio_tuneblocking) > ADIOI_BGL_Calc_others_req(fd, count_my_req_procs, > count_my_req_per_proc, my_req, > nprocs, myrank, > &count_others_req_procs, &others_req); > else > ADIOI_Calc_others_req(fd, count_my_req_procs, > count_my_req_per_proc, my_req, > nprocs, myrank, > &count_others_req_procs, &others_req); > > #if BGL_PROFILE > BGLMPIO_T_CIO_SET_GET( 0, w, 1, 1, 1, BGLMPIO_CIO_DEXCH, BGLMPIO_CIO_OTHREQ ) > #endif > > ADIOI_Free(count_my_req_per_proc); > for (i=0; i < nprocs; i++) { > if (my_req[i].count) { > ADIOI_Free(my_req[i].offsets); > ADIOI_Free(my_req[i].lens); > } > } > ADIOI_Free(my_req); > > /* exchange data and write in sizes of no more than coll_bufsize. */ > ADIOI_Exch_and_write(fd, buf, datatype, nprocs, myrank, > others_req, offset_list, > len_list, contig_access_count, min_st_offset, > fd_size, fd_start, fd_end, buf_idx, error_code); > > #if BGL_PROFILE > BGLMPIO_T_CIO_SET_GET( 0, w, 1, 0, 1, BGLMPIO_CIO_LAST, BGLMPIO_CIO_T_DEXCH ) > BGLMPIO_T_CIO_SET_GET( 0, w, 0, 0, 1, BGLMPIO_CIO_LAST, BGLMPIO_CIO_T_MPIO_CRW ) > > BGLMPIO_T_CIO_REPORT( 0, w, fd, myrank ) > #endif > > > /* free all memory allocated for collective I/O */ > > for (i=0; i if (others_req[i].count) { > ADIOI_Free(others_req[i].offsets); > ADIOI_Free(others_req[i].lens); > ADIOI_Free(others_req[i].mem_ptrs); > } > } > ADIOI_Free(others_req); > > ADIOI_Free(buf_idx); > ADIOI_Free(offset_list); > ADIOI_Free(len_list); > ADIOI_Free(st_offsets); > ADIOI_Free(end_offsets); > ADIOI_Free(fd_start); > ADIOI_Free(fd_end); > > #ifdef HAVE_STATUS_SET_BYTES > if (status) { > int bufsize, size; > /* Don't set status if it isn't needed */ > MPI_Type_size(datatype, &size); > bufsize = size * count; > MPIR_Status_set_bytes(status, datatype, bufsize); > } > /* This is a temporary way of filling in status. The right way is to > keep track of how much data was actually written during collective I/O. */ > #endif > > fd->fp_sys_posn = -1; /* set it to null. */ > } > > > > /* If successful, error_code is set to MPI_SUCCESS. Otherwise an error > * code is created and returned in error_code. > */ > static void ADIOI_Exch_and_write(ADIO_File fd, void *buf, MPI_Datatype > datatype, int nprocs, int myrank, > ADIOI_Access > *others_req, ADIO_Offset *offset_list, > int *len_list, int contig_access_count, > ADIO_Offset > min_st_offset, ADIO_Offset fd_size, > ADIO_Offset *fd_start, ADIO_Offset *fd_end, > int *buf_idx, int *error_code) > { > /* Send data to appropriate processes and write in sizes of no more > than coll_bufsize. > The idea is to reduce the amount of extra memory required for > collective I/O. If all data were written all at once, which is much > easier, it would require temp space more than the size of user_buf, > which is often unacceptable. For example, to write a distributed > array to a file, where each local array is 8Mbytes, requiring > at least another 8Mbytes of temp space is unacceptable. */ > > int hole, i, j, m, size=0, ntimes, max_ntimes, buftype_is_contig; > ADIO_Offset st_loc=-1, end_loc=-1, off, done, req_off; > char *write_buf=NULL; > int *curr_offlen_ptr, *count, *send_size, req_len, *recv_size; > int *partial_recv, *sent_to_proc, *start_pos, flag; > int *send_buf_idx, *curr_to_proc, *done_to_proc; > MPI_Status status; > ADIOI_Flatlist_node *flat_buf=NULL; > MPI_Aint buftype_extent; > int info_flag, coll_bufsize; > char *value; > static char myname[] = "ADIOI_EXCH_AND_WRITE"; > > *error_code = MPI_SUCCESS; /* changed below if error */ > /* only I/O errors are currently reported */ > > /* calculate the number of writes of size coll_bufsize > to be done by each process and the max among all processes. > That gives the no. of communication phases as well. */ > > value = (char *) ADIOI_Malloc((MPI_MAX_INFO_VAL+1)*sizeof(char)); > MPI_Info_get(fd->info, "cb_buffer_size", MPI_MAX_INFO_VAL, value, > &info_flag); > coll_bufsize = atoi(value); > ADIOI_Free(value); > > > for (i=0; i < nprocs; i++) { > if (others_req[i].count) { > st_loc = others_req[i].offsets[0]; > end_loc = others_req[i].offsets[0]; > break; > } > } > > for (i=0; i < nprocs; i++) > for (j=0; j < others_req[i].count; j++) { > st_loc = ADIOI_MIN(st_loc, others_req[i].offsets[j]); > end_loc = ADIOI_MAX(end_loc, (others_req[i].offsets[j] > + others_req[i].lens[j] - 1)); > } > > /* ntimes=ceiling_div(end_loc - st_loc + 1, coll_bufsize)*/ > > ntimes = (int) ((end_loc - st_loc + coll_bufsize)/coll_bufsize); > > if ((st_loc==-1) && (end_loc==-1)) { > ntimes = 0; /* this process does no writing. */ > } > > MPI_Allreduce(&ntimes, &max_ntimes, 1, MPI_INT, MPI_MAX, > fd->comm); > > if (ntimes) write_buf = (char *) ADIOI_Malloc(coll_bufsize); > > curr_offlen_ptr = (int *) ADIOI_Calloc(nprocs, sizeof(int)); > /* its use is explained below. calloc initializes to 0. */ > > count = (int *) ADIOI_Malloc(nprocs*sizeof(int)); > /* to store count of how many off-len pairs per proc are satisfied > in an iteration. */ > > partial_recv = (int *) ADIOI_Calloc(nprocs, sizeof(int)); > /* if only a portion of the last off-len pair is recd. from a process > in a particular iteration, the length recd. is stored here. > calloc initializes to 0. */ > > send_size = (int *) ADIOI_Malloc(nprocs*sizeof(int)); > /* total size of data to be sent to each proc. in an iteration. > Of size nprocs so that I can use MPI_Alltoall later. */ > > recv_size = (int *) ADIOI_Malloc(nprocs*sizeof(int)); > /* total size of data to be recd. from each proc. in an iteration.*/ > > sent_to_proc = (int *) ADIOI_Calloc(nprocs, sizeof(int)); > /* amount of data sent to each proc so far. Used in > ADIOI_Fill_send_buffer. initialized to 0 here. */ > > send_buf_idx = (int *) ADIOI_Malloc(nprocs*sizeof(int)); > curr_to_proc = (int *) ADIOI_Malloc(nprocs*sizeof(int)); > done_to_proc = (int *) ADIOI_Malloc(nprocs*sizeof(int)); > /* Above three are used in ADIOI_Fill_send_buffer*/ > > start_pos = (int *) ADIOI_Malloc(nprocs*sizeof(int)); > /* used to store the starting value of curr_offlen_ptr[i] in > this iteration */ > > ADIOI_Datatype_iscontig(datatype, &buftype_is_contig); > if (!buftype_is_contig) { > ADIOI_Flatten_datatype(datatype); > flat_buf = ADIOI_Flatlist; > while (flat_buf->type != datatype) flat_buf = flat_buf->next; > } > MPI_Type_extent(datatype, &buftype_extent); > > > /* I need to check if there are any outstanding nonblocking writes to > the file, which could potentially interfere with the writes taking > place in this collective write call. Since this is not likely to be > common, let me do the simplest thing possible here: Each process > completes all pending nonblocking operations before completing. */ > > /*ADIOI_Complete_async(error_code); > if (*error_code != MPI_SUCCESS) return; > MPI_Barrier(fd->comm); > */ > > done = 0; > off = st_loc; > > #ifdef PROFILE > MPE_Log_event(14, 0, "end computation"); > #endif > > for (m=0; m < ntimes; m++) { > /* go through all others_req and check which will be satisfied > by the current write */ > > /* Note that MPI guarantees that displacements in filetypes are in > monotonically nondecreasing order and that, for writes, the > filetypes cannot specify overlapping regions in the file. This > simplifies implementation a bit compared to reads. */ > > /* off = start offset in the file for the data to be written in > this iteration > size = size of data written (bytes) corresponding to off > req_off = off in file for a particular contiguous request > minus what was satisfied in previous iteration > req_size = size corresponding to req_off */ > > /* first calculate what should be communicated */ > > #ifdef PROFILE > MPE_Log_event(13, 0, "start computation"); > #endif > for (i=0; i < nprocs; i++) count[i] = recv_size[i] = 0; > > size = (int) (ADIOI_MIN(coll_bufsize, end_loc-st_loc+1-done)); > > for (i=0; i < nprocs; i++) { > if (others_req[i].count) { > start_pos[i] = curr_offlen_ptr[i]; > for (j=curr_offlen_ptr[i]; j if (partial_recv[i]) { > /* this request may have been partially > satisfied in the previous iteration. */ > req_off = others_req[i].offsets[j] + > partial_recv[i]; > req_len = others_req[i].lens[j] - > partial_recv[i]; > partial_recv[i] = 0; > /* modify the off-len pair to reflect this change */ > others_req[i].offsets[j] = req_off; > others_req[i].lens[j] = req_len; > } > else { > req_off = others_req[i].offsets[j]; > req_len = others_req[i].lens[j]; > } > if (req_off < off + size) { > count[i]++; > MPI_Address(write_buf+req_off-off, > &(others_req[i].mem_ptrs[j])); > recv_size[i] += (int)(ADIOI_MIN(off + (ADIO_Offset)size - > req_off, req_len)); > > if (off+size-req_off < req_len) > { > partial_recv[i] = (int) (off + size - req_off); > > /* --BEGIN ERROR HANDLING-- */ > if ((j+1 < others_req[i].count) && > (others_req[i].offsets[j+1] < off+size)) > { > *error_code = MPIO_Err_create_code(MPI_SUCCESS, > MPIR_ERR_RECOVERABLE, > myname, > __LINE__, > MPI_ERR_ARG, > "Filetype specifies overlapping write regions (which is illegal according to the MPI-2 specification)", 0); > /* allow to continue since additional > * communication might have to occur > */ > } > /* --END ERROR HANDLING-- */ > break; > } > } > else break; > } > curr_offlen_ptr[i] = j; > } > } > > #ifdef PROFILE > MPE_Log_event(14, 0, "end computation"); > MPE_Log_event(7, 0, "start communication"); > #endif > if (bglmpio_comm == 1) > ADIOI_W_Exchange_data(fd, buf, write_buf, flat_buf, offset_list, > len_list, send_size, recv_size, off, size, count, > start_pos, partial_recv, > sent_to_proc, nprocs, myrank, > buftype_is_contig, contig_access_count, > min_st_offset, fd_size, fd_start, fd_end, > others_req, send_buf_idx, curr_to_proc, > done_to_proc, &hole, m, buftype_extent, buf_idx, > error_code); > else > if (bglmpio_comm == 0) > ADIOI_W_Exchange_data_alltoallv(fd, buf, write_buf, flat_buf, offset_list, > len_list, send_size, recv_size, off, size, count, > start_pos, partial_recv, > sent_to_proc, nprocs, myrank, > buftype_is_contig, contig_access_count, > min_st_offset, fd_size, fd_start, fd_end, > others_req, send_buf_idx, curr_to_proc, > done_to_proc, &hole, m, buftype_extent, buf_idx, > error_code); > if (*error_code != MPI_SUCCESS) return; > #ifdef PROFILE > MPE_Log_event(8, 0, "end communication"); > #endif > > flag = 0; > for (i=0; i if (count[i]) flag = 1; > > if (flag) { > ADIO_WriteContig(fd, write_buf, size, MPI_BYTE, ADIO_EXPLICIT_OFFSET, > off, &status, error_code); > if (*error_code != MPI_SUCCESS) return; > } > > off += size; > done += size; > } > > for (i=0; i #ifdef PROFILE > MPE_Log_event(7, 0, "start communication"); > #endif > for (m=ntimes; m /* nothing to recv, but check for send. */ > if (bglmpio_comm == 1) > ADIOI_W_Exchange_data(fd, buf, write_buf, flat_buf, offset_list, > len_list, send_size, recv_size, off, size, count, > start_pos, partial_recv, > sent_to_proc, nprocs, myrank, > buftype_is_contig, contig_access_count, > min_st_offset, fd_size, fd_start, fd_end, > others_req, send_buf_idx, > curr_to_proc, done_to_proc, &hole, m, > buftype_extent, buf_idx, error_code); > else > if (bglmpio_comm == 0) > ADIOI_W_Exchange_data_alltoallv(fd, buf, write_buf, flat_buf, offset_list, > len_list, send_size, recv_size, off, size, count, > start_pos, partial_recv, > sent_to_proc, nprocs, myrank, > buftype_is_contig, contig_access_count, > min_st_offset, fd_size, fd_start, fd_end, > others_req, send_buf_idx, > curr_to_proc, done_to_proc, &hole, m, > buftype_extent, buf_idx, error_code); > if (*error_code != MPI_SUCCESS) return; > #ifdef PROFILE > MPE_Log_event(8, 0, "end communication"); > #endif > > if (ntimes) ADIOI_Free(write_buf); > ADIOI_Free(curr_offlen_ptr); > ADIOI_Free(count); > ADIOI_Free(partial_recv); > ADIOI_Free(send_size); > ADIOI_Free(recv_size); > ADIOI_Free(sent_to_proc); > ADIOI_Free(start_pos); > ADIOI_Free(send_buf_idx); > ADIOI_Free(curr_to_proc); > ADIOI_Free(done_to_proc); > } > > > /* Sets error_code to MPI_SUCCESS if successful, or creates an error code > * in the case of error. > */ > static void ADIOI_W_Exchange_data(ADIO_File fd, void *buf, char *write_buf, > ADIOI_Flatlist_node *flat_buf, ADIO_Offset > *offset_list, int *len_list, int *send_size, > int *recv_size, ADIO_Offset off, int size, > int *count, int *start_pos, > int *partial_recv, > int *sent_to_proc, int nprocs, > int myrank, int > buftype_is_contig, int contig_access_count, > ADIO_Offset min_st_offset, > ADIO_Offset fd_size, > ADIO_Offset *fd_start, ADIO_Offset *fd_end, > ADIOI_Access *others_req, > int *send_buf_idx, int *curr_to_proc, > int *done_to_proc, int *hole, int iter, > MPI_Aint buftype_extent, int *buf_idx, > int *error_code) > { > int i, j, k, *tmp_len, nprocs_recv, nprocs_send, err; > char **send_buf = NULL; > MPI_Request *requests, *send_req; > MPI_Datatype *recv_types; > MPI_Status *statuses, status; > int *srt_len, sum; > ADIO_Offset *srt_off; > static char myname[] = "ADIOI_W_EXCHANGE_DATA"; > > /* exchange recv_size info so that each process knows how much to > send to whom. */ > > MPI_Alltoall(recv_size, 1, MPI_INT, send_size, 1, MPI_INT, fd->comm); > > /* create derived datatypes for recv */ > > nprocs_recv = 0; > for (i=0; i > recv_types = (MPI_Datatype *) > ADIOI_Malloc((nprocs_recv+1)*sizeof(MPI_Datatype)); > /* +1 to avoid a 0-size malloc */ > > tmp_len = (int *) ADIOI_Malloc(nprocs*sizeof(int)); > j = 0; > for (i=0; i if (recv_size[i]) { > /* take care if the last off-len pair is a partial recv */ > if (partial_recv[i]) { > k = start_pos[i] + count[i] - 1; > tmp_len[i] = others_req[i].lens[k]; > others_req[i].lens[k] = partial_recv[i]; > } > MPI_Type_hindexed(count[i], > &(others_req[i].lens[start_pos[i]]), > &(others_req[i].mem_ptrs[start_pos[i]]), > MPI_BYTE, recv_types+j); > /* absolute displacements; use MPI_BOTTOM in recv */ > MPI_Type_commit(recv_types+j); > j++; > } > } > > /* To avoid a read-modify-write, check if there are holes in the > data to be written. For this, merge the (sorted) offset lists > others_req using a heap-merge. */ > > sum = 0; > for (i=0; i srt_off = (ADIO_Offset *) ADIOI_Malloc((sum+1)*sizeof(ADIO_Offset)); > srt_len = (int *) ADIOI_Malloc((sum+1)*sizeof(int)); > /* +1 to avoid a 0-size malloc */ > > ADIOI_Heap_merge(others_req, count, srt_off, srt_len, start_pos, > nprocs, nprocs_recv, sum); > > /* for partial recvs, restore original lengths */ > for (i=0; i if (partial_recv[i]) { > k = start_pos[i] + count[i] - 1; > others_req[i].lens[k] = tmp_len[i]; > } > ADIOI_Free(tmp_len); > > /* check if there are any holes */ > *hole = 0; > /* See if there are holes before the first request or after the last request*/ > if((srt_off[0] > off) || > ((srt_off[sum-1] + srt_len[sum-1]) < (off + size))) > { > *hole = 1; > } > else /* See if there are holes between the requests, if there are more than one */ > for (i=0; i if (srt_off[i]+srt_len[i] < srt_off[i+1]) { > *hole = 1; > break; > } > > ADIOI_Free(srt_off); > ADIOI_Free(srt_len); > > if (nprocs_recv) { > if (*hole) { > ADIO_ReadContig(fd, write_buf, size, MPI_BYTE, > ADIO_EXPLICIT_OFFSET, off, &status, &err); > /* --BEGIN ERROR HANDLING-- */ > if (err != MPI_SUCCESS) { > *error_code = MPIO_Err_create_code(err, > MPIR_ERR_RECOVERABLE, myname, > __LINE__, MPI_ERR_IO, > "**ioRMWrdwr", 0); > return; > } > /* --END ERROR HANDLING-- */ > } > } > > nprocs_send = 0; > for (i=0; i < nprocs; i++) if (send_size[i]) nprocs_send++; > > if (fd->atomicity) { > /* bug fix from Wei-keng Liao and Kenin Coloma */ > requests = (MPI_Request *) > ADIOI_Malloc((nprocs_send+1)*sizeof(MPI_Request)); > send_req = requests; > } > else { > requests = (MPI_Request *) > ADIOI_Malloc((nprocs_send+nprocs_recv+1)*sizeof(MPI_Request)); > /* +1 to avoid a 0-size malloc */ > > /* post receives */ > j = 0; > for (i=0; i if (recv_size[i]) { > MPI_Irecv(MPI_BOTTOM, 1, recv_types[j], i, myrank+i+100*iter, > fd->comm, requests+j); > j++; > } > } > send_req = requests + nprocs_recv; > } > > /* post sends. if buftype_is_contig, data can be directly sent from > user buf at location given by buf_idx. else use send_buf. */ > > if (buftype_is_contig) { > j = 0; > for (i=0; i < nprocs; i++) > if (send_size[i]) { > MPI_Isend(((char *) buf) + buf_idx[i], send_size[i], > MPI_BYTE, i, myrank+i+100*iter, fd->comm, > send_req+j); > j++; > buf_idx[i] += send_size[i]; > } > } > else if (nprocs_send) { > /* buftype is not contig */ > send_buf = (char **) ADIOI_Malloc(nprocs*sizeof(char*)); > for (i=0; i < nprocs; i++) > if (send_size[i]) > send_buf[i] = (char *) ADIOI_Malloc(send_size[i]); > > ADIOI_Fill_send_buffer(fd, buf, flat_buf, send_buf, > offset_list, len_list, send_size, > send_req, > sent_to_proc, nprocs, myrank, > contig_access_count, > min_st_offset, fd_size, fd_start, fd_end, > send_buf_idx, curr_to_proc, done_to_proc, iter, > buftype_extent); > /* the send is done in ADIOI_Fill_send_buffer */ > } > > if (fd->atomicity) { > /* bug fix from Wei-keng Liao and Kenin Coloma */ > j = 0; > for (i=0; i MPI_Status wkl_status; > if (recv_size[i]) { > MPI_Recv(MPI_BOTTOM, 1, recv_types[j], i, myrank+i+100*iter, > fd->comm, &wkl_status); > j++; > } > } > } > > for (i=0; i ADIOI_Free(recv_types); > > if (fd->atomicity) { > /* bug fix from Wei-keng Liao and Kenin Coloma */ > statuses = (MPI_Status *) ADIOI_Malloc((nprocs_send+1) * \ > sizeof(MPI_Status)); > /* +1 to avoid a 0-size malloc */ > } > else { > statuses = (MPI_Status *) ADIOI_Malloc((nprocs_send+nprocs_recv+1) * \ > sizeof(MPI_Status)); > /* +1 to avoid a 0-size malloc */ > } > > #ifdef NEEDS_MPI_TEST > i = 0; > if (fd->atomicity) { > /* bug fix from Wei-keng Liao and Kenin Coloma */ > while (!i) MPI_Testall(nprocs_send, send_req, &i, statuses); > } > else { > while (!i) MPI_Testall(nprocs_send+nprocs_recv, requests, &i, statuses); > } > #else > if (fd->atomicity) > /* bug fix from Wei-keng Liao and Kenin Coloma */ > MPI_Waitall(nprocs_send, send_req, statuses); > else > MPI_Waitall(nprocs_send+nprocs_recv, requests, statuses); > #endif > > ADIOI_Free(statuses); > ADIOI_Free(requests); > if (!buftype_is_contig && nprocs_send) { > for (i=0; i < nprocs; i++) > if (send_size[i]) ADIOI_Free(send_buf[i]); > ADIOI_Free(send_buf); > } > } > > > #define ADIOI_BUF_INCR \ > { \ > while (buf_incr) { \ > size_in_buf = ADIOI_MIN(buf_incr, flat_buf_sz); \ > user_buf_idx += size_in_buf; \ > flat_buf_sz -= size_in_buf; \ > if (!flat_buf_sz) { \ > if (flat_buf_idx < (flat_buf->count - 1)) flat_buf_idx++; \ > else { \ > flat_buf_idx = 0; \ > n_buftypes++; \ > } \ > user_buf_idx = flat_buf->indices[flat_buf_idx] + \ > n_buftypes*buftype_extent; \ > flat_buf_sz = flat_buf->blocklens[flat_buf_idx]; \ > } \ > buf_incr -= size_in_buf; \ > } \ > } > > > #define ADIOI_BUF_COPY \ > { \ > while (size) { \ > size_in_buf = ADIOI_MIN(size, flat_buf_sz); \ > memcpy(&(send_buf[p][send_buf_idx[p]]), \ > ((char *) buf) + user_buf_idx, size_in_buf); \ > send_buf_idx[p] += size_in_buf; \ > user_buf_idx += size_in_buf; \ > flat_buf_sz -= size_in_buf; \ > if (!flat_buf_sz) { \ > if (flat_buf_idx < (flat_buf->count - 1)) flat_buf_idx++; \ > else { \ > flat_buf_idx = 0; \ > n_buftypes++; \ > } \ > user_buf_idx = flat_buf->indices[flat_buf_idx] + \ > n_buftypes*buftype_extent; \ > flat_buf_sz = flat_buf->blocklens[flat_buf_idx]; \ > } \ > size -= size_in_buf; \ > buf_incr -= size_in_buf; \ > } \ > ADIOI_BUF_INCR \ > } > > > > static void ADIOI_Fill_send_buffer(ADIO_File fd, void *buf, ADIOI_Flatlist_node > *flat_buf, char **send_buf, ADIO_Offset > *offset_list, int *len_list, int *send_size, > MPI_Request *requests, int *sent_to_proc, > int nprocs, int myrank, > int contig_access_count, > ADIO_Offset min_st_offset, ADIO_Offset fd_size, > ADIO_Offset *fd_start, ADIO_Offset *fd_end, > int *send_buf_idx, int *curr_to_proc, > int *done_to_proc, int iter, > MPI_Aint buftype_extent) > { > /* this function is only called if buftype is not contig */ > > int i, p, flat_buf_idx, size; > int flat_buf_sz, buf_incr, size_in_buf, jj, n_buftypes; > ADIO_Offset off, len, rem_len, user_buf_idx; > > /* curr_to_proc[p] = amount of data sent to proc. p that has already > been accounted for so far > done_to_proc[p] = amount of data already sent to proc. p in > previous iterations > user_buf_idx = current location in user buffer > send_buf_idx[p] = current location in send_buf of proc. p */ > > for (i=0; i < nprocs; i++) { > send_buf_idx[i] = curr_to_proc[i] = 0; > done_to_proc[i] = sent_to_proc[i]; > } > jj = 0; > > user_buf_idx = flat_buf->indices[0]; > flat_buf_idx = 0; > n_buftypes = 0; > flat_buf_sz = flat_buf->blocklens[0]; > > /* flat_buf_idx = current index into flattened buftype > flat_buf_sz = size of current contiguous component in > flattened buf */ > > for (i=0; i off = offset_list[i]; > rem_len = (ADIO_Offset) len_list[i]; > > /*this request may span the file domains of more than one process*/ > while (rem_len != 0) { > len = rem_len; > /* NOTE: len value is modified by ADIOI_Calc_aggregator() to be no > * longer than the single region that processor "p" is responsible > * for. > */ > p = ADIOI_BGL_Calc_aggregator(fd, > off, > min_st_offset, > &len, > fd_size, > fd_start, > fd_end); > > if (send_buf_idx[p] < send_size[p]) { > if (curr_to_proc[p]+len > done_to_proc[p]) { > if (done_to_proc[p] > curr_to_proc[p]) { > size = (int)ADIOI_MIN(curr_to_proc[p] + len - > done_to_proc[p], send_size[p]-send_buf_idx[p]); > buf_incr = done_to_proc[p] - curr_to_proc[p]; > ADIOI_BUF_INCR > buf_incr = (int)(curr_to_proc[p] + len - done_to_proc[p]); > curr_to_proc[p] = done_to_proc[p] + size; > ADIOI_BUF_COPY > } > else { > size = (int)ADIOI_MIN(len,send_size[p]-send_buf_idx[p]); > buf_incr = (int)len; > curr_to_proc[p] += size; > ADIOI_BUF_COPY > } > if (send_buf_idx[p] == send_size[p]) { > MPI_Isend(send_buf[p], send_size[p], MPI_BYTE, p, > myrank+p+100*iter, fd->comm, requests+jj); > jj++; > } > } > else { > curr_to_proc[p] += (int)len; > buf_incr = (int)len; > ADIOI_BUF_INCR > } > } > else { > buf_incr = (int)len; > ADIOI_BUF_INCR > } > off += len; > rem_len -= len; > } > } > for (i=0; i < nprocs; i++) > if (send_size[i]) sent_to_proc[i] = curr_to_proc[i]; > } > > > > static void ADIOI_Heap_merge(ADIOI_Access *others_req, int *count, > ADIO_Offset *srt_off, int *srt_len, int *start_pos, > int nprocs, int nprocs_recv, int total_elements) > { > typedef struct { > ADIO_Offset *off_list; > int *len_list; > int nelem; > } heap_struct; > > heap_struct *a, tmp; > int i, j, heapsize, l, r, k, smallest; > > a = (heap_struct *) ADIOI_Malloc((nprocs_recv+1)*sizeof(heap_struct)); > > j = 0; > for (i=0; i if (count[i]) { > a[j].off_list = &(others_req[i].offsets[start_pos[i]]); > a[j].len_list = &(others_req[i].lens[start_pos[i]]); > a[j].nelem = count[i]; > j++; > } > > /* build a heap out of the first element from each list, with > the smallest element of the heap at the root */ > > heapsize = nprocs_recv; > for (i=heapsize/2 - 1; i>=0; i--) { > /* Heapify(a, i, heapsize); Algorithm from Cormen et al. pg. 143 > modified for a heap with smallest element at root. I have > removed the recursion so that there are no function calls. > Function calls are too expensive. */ > k = i; > while (1) { > l = 2*(k+1) - 1; > r = 2*(k+1); > > if ((l < heapsize) && > (*(a[l].off_list) < *(a[k].off_list))) > smallest = l; > else smallest = k; > > if ((r < heapsize) && > (*(a[r].off_list) < *(a[smallest].off_list))) > smallest = r; > > if (smallest != k) { > tmp.off_list = a[k].off_list; > tmp.len_list = a[k].len_list; > tmp.nelem = a[k].nelem; > > a[k].off_list = a[smallest].off_list; > a[k].len_list = a[smallest].len_list; > a[k].nelem = a[smallest].nelem; > > a[smallest].off_list = tmp.off_list; > a[smallest].len_list = tmp.len_list; > a[smallest].nelem = tmp.nelem; > > k = smallest; > } > else break; > } > } > > for (i=0; i /* extract smallest element from heap, i.e. the root */ > srt_off[i] = *(a[0].off_list); > srt_len[i] = *(a[0].len_list); > (a[0].nelem)--; > > if (!a[0].nelem) { > a[0].off_list = a[heapsize-1].off_list; > a[0].len_list = a[heapsize-1].len_list; > a[0].nelem = a[heapsize-1].nelem; > heapsize--; > } > else { > (a[0].off_list)++; > (a[0].len_list)++; > } > > /* Heapify(a, 0, heapsize); */ > k = 0; > while (1) { > l = 2*(k+1) - 1; > r = 2*(k+1); > > if ((l < heapsize) && > (*(a[l].off_list) < *(a[k].off_list))) > smallest = l; > else smallest = k; > > if ((r < heapsize) && > (*(a[r].off_list) < *(a[smallest].off_list))) > smallest = r; > > if (smallest != k) { > tmp.off_list = a[k].off_list; > tmp.len_list = a[k].len_list; > tmp.nelem = a[k].nelem; > > a[k].off_list = a[smallest].off_list; > a[k].len_list = a[smallest].len_list; > a[k].nelem = a[smallest].nelem; > > a[smallest].off_list = tmp.off_list; > a[smallest].len_list = tmp.len_list; > a[smallest].nelem = tmp.nelem; > > k = smallest; > } > else break; > } > } > > ADIOI_Free(a); > } > > > static void ADIOI_W_Exchange_data_alltoallv( > ADIO_File fd, void *buf, > char *write_buf, /* 1 */ > ADIOI_Flatlist_node *flat_buf, > ADIO_Offset *offset_list, > int *len_list, int *send_size, int *recv_size, > ADIO_Offset off, int size, /* 2 */ > int *count, int *start_pos, int *partial_recv, > int *sent_to_proc, int nprocs, int myrank, > int buftype_is_contig, int contig_access_count, > ADIO_Offset min_st_offset, > ADIO_Offset fd_size, > ADIO_Offset *fd_start, > ADIO_Offset *fd_end, > ADIOI_Access *others_req, > int *send_buf_idx, int *curr_to_proc, /* 3 */ > int *done_to_proc, int *hole, /* 4 */ > int iter, MPI_Aint buftype_extent, int *buf_idx, > int *error_code) > { > int i, j, k=0, tmp=0, nprocs_recv, nprocs_send, erri, *tmp_len, err; > char **send_buf = NULL; > MPI_Request *requests, *send_req; > MPI_Datatype recv_type; > MPI_Status *statuses, status; > int rtail, stail; > char *sbuf_ptr, *to_ptr; > int len; > int *sdispls, *rdispls; > char *all_recv_buf, *all_send_buf; > int *srt_len, sum; > ADIO_Offset *srt_off; > static char myname[] = "ADIOI_W_EXCHANGE_DATA"; > > > /* exchange recv_size info so that each process knows how much to > send to whom. */ > MPI_Alltoall(recv_size, 1, MPI_INT, send_size, 1, MPI_INT, fd->comm); > > nprocs_recv = 0; > for (i=0; i nprocs_send = 0; > for (i=0; i > /* receiver side data structures */ > rdispls = (int *) ADIOI_Malloc( nprocs * sizeof(int) ); > rtail = 0; > for (i=0; i > /* data buffer */ > all_recv_buf = (char *) ADIOI_Malloc( rtail ); > > /* sender side data structures */ > sdispls = (int *) ADIOI_Malloc( nprocs * sizeof(int) ); > stail = 0; > for (i=0; i > /* data buffer */ > all_send_buf = (char *) ADIOI_Malloc( stail ); > if (buftype_is_contig) { > for (i=0; i { > if (send_size[i]) { > sbuf_ptr = all_send_buf + sdispls[i]; > memcpy( sbuf_ptr, buf + buf_idx[i], send_size[i] ); > buf_idx[i] += send_size[i]; > } > } > } else { > send_buf = (char **) ADIOI_Malloc( nprocs * sizeof(char *) ); > for (i=0; i send_buf[i] = all_send_buf + sdispls[i]; > ADIOI_Fill_send_buffer_nosend(fd, buf, flat_buf, send_buf, > offset_list, len_list, send_size, > send_req, > sent_to_proc, nprocs, myrank, > contig_access_count, > min_st_offset, fd_size, fd_start, fd_end, > send_buf_idx, curr_to_proc, done_to_proc, iter, > buftype_extent); > } > > /* alltoallv */ > MPI_Alltoallv( > all_send_buf, send_size, sdispls, MPI_BYTE, > all_recv_buf, recv_size, rdispls, MPI_BYTE, > fd->comm ); > > /* data sieving pre-read */ > /* To avoid a read-modify-write, check if there are holes in the > data to be written. For this, merge the (sorted) offset lists > others_req using a heap-merge. */ > > sum = 0; > for (i=0; i srt_off = (ADIO_Offset *) ADIOI_Malloc((sum+1)*sizeof(ADIO_Offset)); > srt_len = (int *) ADIOI_Malloc((sum+1)*sizeof(int)); > > ADIOI_Heap_merge(others_req, count, srt_off, srt_len, start_pos, > nprocs, nprocs_recv, sum); > > /* check if there are any holes */ > *hole = 0; > /* See if there are holes before the first request or after the last request*/ > if((srt_off[0] > off) || > ((srt_off[sum-1] + srt_len[sum-1]) < (off + size))) > { > *hole = 1; > } > else /* See if there are holes between the requests, if there are more than one */ > for (i=0; i if (srt_off[i]+srt_len[i] < srt_off[i+1]) { > *hole = 1; > break; > } > > ADIOI_Free(srt_off); > ADIOI_Free(srt_len); > > if (nprocs_recv) { > if (*hole) { > ADIO_ReadContig(fd, write_buf, size, MPI_BYTE, > ADIO_EXPLICIT_OFFSET, off, &status, &err); > /* --BEGIN ERROR HANDLING-- */ > if (err != MPI_SUCCESS) { > *error_code = MPIO_Err_create_code(err, > MPIR_ERR_RECOVERABLE, myname, > __LINE__, MPI_ERR_IO, > "**ioRMWrdwr", 0); > return; > } > /* --END ERROR HANDLING-- */ > } > } > > /* scater all_recv_buf into 4M cb_buffer */ > tmp_len = (int *) ADIOI_Malloc(nprocs*sizeof(int)); > for (i=0; i { > if (recv_size[i]) { > if (partial_recv[i]) { > k = start_pos[i] + count[i] - 1; > tmp_len[i] = others_req[i].lens[k]; > others_req[i].lens[k] = partial_recv[i]; > } > > sbuf_ptr = all_recv_buf + rdispls[i]; > for (j=0; j to_ptr = (char *)( others_req[i].mem_ptrs[ start_pos[i]+j ] ); > len = others_req[i].lens[ start_pos[i]+j ] ; > memcpy( to_ptr, sbuf_ptr, len ); > sbuf_ptr += len; > } > > /* restore */ > if (partial_recv[i]) { > k = start_pos[i] + count[i] - 1; > others_req[i].lens[k] = tmp_len[i]; > } > > } > } > > ADIOI_Free( tmp_len ); > ADIOI_Free( all_send_buf ); > ADIOI_Free( all_recv_buf ); > ADIOI_Free(sdispls); > ADIOI_Free(rdispls); > return; > } > > static void ADIOI_Fill_send_buffer_nosend(ADIO_File fd, void *buf, ADIOI_Flatlist_node > *flat_buf, char **send_buf, ADIO_Offset > *offset_list, int *len_list, int *send_size, > MPI_Request *requests, int *sent_to_proc, > int nprocs, int myrank, > int contig_access_count, > ADIO_Offset min_st_offset, ADIO_Offset fd_size, > ADIO_Offset *fd_start, ADIO_Offset *fd_end, > int *send_buf_idx, int *curr_to_proc, > int *done_to_proc, int iter, > MPI_Aint buftype_extent) > { > /* this function is only called if buftype is not contig */ > > int i, p, flat_buf_idx, size; > int flat_buf_sz, buf_incr, size_in_buf, jj, n_buftypes; > ADIO_Offset off, len, rem_len, user_buf_idx; > > /* curr_to_proc[p] = amount of data sent to proc. p that has already > been accounted for so far > done_to_proc[p] = amount of data already sent to proc. p in > previous iterations > user_buf_idx = current location in user buffer > send_buf_idx[p] = current location in send_buf of proc. p */ > > for (i=0; i < nprocs; i++) { > send_buf_idx[i] = curr_to_proc[i] = 0; > done_to_proc[i] = sent_to_proc[i]; > } > jj = 0; > > user_buf_idx = flat_buf->indices[0]; > flat_buf_idx = 0; > n_buftypes = 0; > flat_buf_sz = flat_buf->blocklens[0]; > > /* flat_buf_idx = current index into flattened buftype > flat_buf_sz = size of current contiguous component in > flattened buf */ > > for (i=0; i off = offset_list[i]; > rem_len = (ADIO_Offset) len_list[i]; > > /*this request may span the file domains of more than one process*/ > while (rem_len != 0) { > len = rem_len; > /* NOTE: len value is modified by ADIOI_Calc_aggregator() to be no > * longer than the single region that processor "p" is responsible > * for. > */ > p = ADIOI_BGL_Calc_aggregator(fd, > off, > min_st_offset, > &len, > fd_size, > fd_start, > fd_end); > > if (send_buf_idx[p] < send_size[p]) { > if (curr_to_proc[p]+len > done_to_proc[p]) { > if (done_to_proc[p] > curr_to_proc[p]) { > size = (int)ADIOI_MIN(curr_to_proc[p] + len - > done_to_proc[p], send_size[p]-send_buf_idx[p]); > buf_incr = done_to_proc[p] - curr_to_proc[p]; > ADIOI_BUF_INCR > buf_incr = (int)(curr_to_proc[p] + len - done_to_proc[p]); > curr_to_proc[p] = done_to_proc[p] + size; > ADIOI_BUF_COPY > } > else { > size = (int)ADIOI_MIN(len,send_size[p]-send_buf_idx[p]); > buf_incr = (int)len; > curr_to_proc[p] += size; > ADIOI_BUF_COPY > } > /* moved to alltoallv */ > /* > if (send_buf_idx[p] == send_size[p]) { > MPI_Isend(send_buf[p], send_size[p], MPI_BYTE, p, > myrank+p+100*iter, fd->comm, requests+jj); > jj++; > } > */ > } > else { > curr_to_proc[p] += (int)len; > buf_incr = (int)len; > ADIOI_BUF_INCR > } > } > else { > buf_incr = (int)len; > ADIOI_BUF_INCR > } > off += len; > rem_len -= len; > } > } > for (i=0; i < nprocs; i++) > if (send_size[i]) sent_to_proc[i] = curr_to_proc[i]; > } diff -rN mpich2-1.0.7rc1/src/mpi/romio/adio/ad_bgl/ad_bgl_write.c bgp-mpich2/src/mpi/romio/adio/ad_bgl/ad_bgl_write.c 0a1,551 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file ad_bgl_write.c > * \brief ??? > */ > > /* -*- Mode: C; c-basic-offset:4 ; -*- */ > /* > * Copyright (C) 1997 University of Chicago. > * See COPYRIGHT notice in top-level directory. > */ > > #include "ad_bgl.h" > #include "adio_extern.h" > > #include "ad_bgl_tuning.h" > > void ADIOI_BGL_WriteContig(ADIO_File fd, void *buf, int count, > MPI_Datatype datatype, int file_ptr_type, > ADIO_Offset offset, ADIO_Status *status, int *error_code) > { > int err=-1, datatype_size, len; > static char myname[] = "ADIOI_BGL_WRITECONTIG"; > > #if BGL_PROFILE > /* timing */ > double io_time, io_time2; > > if (bglmpio_timing) { > io_time = MPI_Wtime(); > bglmpio_prof_cw[ BGLMPIO_CIO_DATA_SIZE ] += len; > } > #endif > > MPI_Type_size(datatype, &datatype_size); > len = datatype_size * count; > > #if BGL_PROFILE > > if (file_ptr_type == ADIO_EXPLICIT_OFFSET) { > if (bglmpio_timing2) io_time2 = MPI_Wtime(); > if (fd->fp_sys_posn != offset) > lseek(fd->fd_sys, offset, SEEK_SET); > if (bglmpio_timing2) bglmpio_prof_cw[ BGLMPIO_CIO_T_SEEK ] += (MPI_Wtime() - io_time2); > ADIOI_WRITE_LOCK(fd, offset, SEEK_SET, len); > if (bglmpio_timing2) io_time2 = MPI_Wtime(); > err = write(fd->fd_sys, buf, len); > if (bglmpio_timing2) bglmpio_prof_cw[ BGLMPIO_CIO_T_POSI_RW ] += (MPI_Wtime() - io_time2); > ADIOI_UNLOCK(fd, offset, SEEK_SET, len); > fd->fp_sys_posn = offset + err; > /* individual file pointer not updated */ > } > else { /* write from curr. location of ind. file pointer */ > offset = fd->fp_ind; > if (bglmpio_timing2) io_time2 = MPI_Wtime(); > if (fd->fp_sys_posn != fd->fp_ind) > lseek(fd->fd_sys, fd->fp_ind, SEEK_SET); > if (bglmpio_timing2) bglmpio_prof_cw[ BGLMPIO_CIO_T_SEEK ] += (MPI_Wtime() - io_time2); > ADIOI_WRITE_LOCK(fd, offset, SEEK_SET, len); > if (bglmpio_timing2) io_time2 = MPI_Wtime(); > err = write(fd->fd_sys, buf, len); > if (bglmpio_timing2) bglmpio_prof_cw[ BGLMPIO_CIO_T_POSI_RW ] += (MPI_Wtime() - io_time2); > ADIOI_UNLOCK(fd, offset, SEEK_SET, len); > fd->fp_ind += err; > fd->fp_sys_posn = fd->fp_ind; > } > > #else /* BGL_PROFILE */ > > if (file_ptr_type == ADIO_EXPLICIT_OFFSET) { > if (fd->fp_sys_posn != offset) > lseek(fd->fd_sys, offset, SEEK_SET); > ADIOI_WRITE_LOCK(fd, offset, SEEK_SET, len); > err = write(fd->fd_sys, buf, len); > ADIOI_UNLOCK(fd, offset, SEEK_SET, len); > fd->fp_sys_posn = offset + err; > /* individual file pointer not updated */ > } > else { /* write from curr. location of ind. file pointer */ > offset = fd->fp_ind; > if (fd->fp_sys_posn != fd->fp_ind) > lseek(fd->fd_sys, fd->fp_ind, SEEK_SET); > ADIOI_WRITE_LOCK(fd, offset, SEEK_SET, len); > err = write(fd->fd_sys, buf, len); > ADIOI_UNLOCK(fd, offset, SEEK_SET, len); > fd->fp_ind += err; > fd->fp_sys_posn = fd->fp_ind; > } > > #endif /* BGL_PROFILE */ > > #if BGL_PROFILE > if (bglmpio_timing) bglmpio_prof_cw[ BGLMPIO_CIO_T_MPIO_RW ] += (MPI_Wtime() - io_time); > #endif > > /* --BEGIN ERROR HANDLING-- */ > if (err == -1) { > *error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, > myname, __LINE__, MPI_ERR_IO, > "**io", > "**io %s", strerror(errno)); > return; > } > /* --END ERROR HANDLING-- */ > > #ifdef HAVE_STATUS_SET_BYTES > MPIR_Status_set_bytes(status, datatype, err); > #endif > > *error_code = MPI_SUCCESS; > } > > > > > #define ADIOI_BUFFERED_WRITE \ > { \ > if (req_off >= writebuf_off + writebuf_len) { \ > lseek(fd->fd_sys, writebuf_off, SEEK_SET); \ > err = write(fd->fd_sys, writebuf, writebuf_len); \ > if (!(fd->atomicity)) ADIOI_UNLOCK(fd, writebuf_off, SEEK_SET, writebuf_len); \ > if (err == -1) err_flag = 1; \ > writebuf_off = req_off; \ > writebuf_len = (int) (ADIOI_MIN(max_bufsize,end_offset-writebuf_off+1));\ > if (!(fd->atomicity)) ADIOI_WRITE_LOCK(fd, writebuf_off, SEEK_SET, writebuf_len); \ > lseek(fd->fd_sys, writebuf_off, SEEK_SET); \ > err = read(fd->fd_sys, writebuf, writebuf_len); \ > if (err == -1) { \ > *error_code = MPIO_Err_create_code(MPI_SUCCESS, \ > MPIR_ERR_RECOVERABLE, myname, \ > __LINE__, MPI_ERR_IO, \ > "**ioRMWrdwr", 0); \ > return; \ > } \ > } \ > write_sz = (int) (ADIOI_MIN(req_len, writebuf_off + writebuf_len - req_off)); \ > memcpy(writebuf+req_off-writebuf_off, (char *)buf +userbuf_off, write_sz);\ > while (write_sz != req_len) { \ > lseek(fd->fd_sys, writebuf_off, SEEK_SET); \ > err = write(fd->fd_sys, writebuf, writebuf_len); \ > if (!(fd->atomicity)) ADIOI_UNLOCK(fd, writebuf_off, SEEK_SET, writebuf_len); \ > if (err == -1) err_flag = 1; \ > req_len -= write_sz; \ > userbuf_off += write_sz; \ > writebuf_off += writebuf_len; \ > writebuf_len = (int) (ADIOI_MIN(max_bufsize,end_offset-writebuf_off+1));\ > if (!(fd->atomicity)) ADIOI_WRITE_LOCK(fd, writebuf_off, SEEK_SET, writebuf_len); \ > lseek(fd->fd_sys, writebuf_off, SEEK_SET); \ > err = read(fd->fd_sys, writebuf, writebuf_len); \ > if (err == -1) { \ > *error_code = MPIO_Err_create_code(MPI_SUCCESS, \ > MPIR_ERR_RECOVERABLE, myname, \ > __LINE__, MPI_ERR_IO, \ > "**ioRMWrdwr", 0); \ > return; \ > } \ > write_sz = ADIOI_MIN(req_len, writebuf_len); \ > memcpy(writebuf, (char *)buf + userbuf_off, write_sz);\ > } \ > } > > > /* this macro is used when filetype is contig and buftype is not contig. > it does not do a read-modify-write and does not lock*/ > #define ADIOI_BUFFERED_WRITE_WITHOUT_READ \ > { \ > if (req_off >= writebuf_off + writebuf_len) { \ > lseek(fd->fd_sys, writebuf_off, SEEK_SET); \ > if (!(fd->atomicity)) ADIOI_WRITE_LOCK(fd, writebuf_off, SEEK_SET, writebuf_len); \ > err = write(fd->fd_sys, writebuf, writebuf_len); \ > if (!(fd->atomicity)) ADIOI_UNLOCK(fd, writebuf_off, SEEK_SET, writebuf_len); \ > if (err == -1) err_flag = 1; \ > writebuf_off = req_off; \ > writebuf_len = (int) (ADIOI_MIN(max_bufsize,end_offset-writebuf_off+1));\ > } \ > write_sz = (int) (ADIOI_MIN(req_len, writebuf_off + writebuf_len - req_off)); \ > memcpy(writebuf+req_off-writebuf_off, (char *)buf +userbuf_off, write_sz);\ > while (write_sz != req_len) { \ > lseek(fd->fd_sys, writebuf_off, SEEK_SET); \ > if (!(fd->atomicity)) ADIOI_WRITE_LOCK(fd, writebuf_off, SEEK_SET, writebuf_len); \ > err = write(fd->fd_sys, writebuf, writebuf_len); \ > if (!(fd->atomicity)) ADIOI_UNLOCK(fd, writebuf_off, SEEK_SET, writebuf_len); \ > if (err == -1) err_flag = 1; \ > req_len -= write_sz; \ > userbuf_off += write_sz; \ > writebuf_off += writebuf_len; \ > writebuf_len = (int) (ADIOI_MIN(max_bufsize,end_offset-writebuf_off+1));\ > write_sz = ADIOI_MIN(req_len, writebuf_len); \ > memcpy(writebuf, (char *)buf + userbuf_off, write_sz);\ > } \ > } > > > > void ADIOI_BGL_WriteStrided(ADIO_File fd, void *buf, int count, > MPI_Datatype datatype, int file_ptr_type, > ADIO_Offset offset, ADIO_Status *status, int > *error_code) > { > /* offset is in units of etype relative to the filetype. */ > > ADIOI_Flatlist_node *flat_buf, *flat_file; > int i, j, k, err=-1, bwr_size, fwr_size=0, st_index=0; > int bufsize, num, size, sum, n_etypes_in_filetype, size_in_filetype; > int n_filetypes, etype_in_filetype; > ADIO_Offset abs_off_in_filetype=0; > int filetype_size, etype_size, buftype_size, req_len; > MPI_Aint filetype_extent, buftype_extent; > int buf_count, buftype_is_contig, filetype_is_contig; > ADIO_Offset userbuf_off; > ADIO_Offset off, req_off, disp, end_offset=0, writebuf_off, start_off; > char *writebuf, *value; > int flag, st_fwr_size, st_n_filetypes, writebuf_len, write_sz; > int new_bwr_size, new_fwr_size, err_flag=0, info_flag, max_bufsize; > static char myname[] = "ADIOI_BGL_WRITESTRIDED"; > > if (fd->hints->ds_write == ADIOI_HINT_DISABLE) { > /* if user has disabled data sieving on reads, use naive > * approach instead. > */ > /*FPRINTF(stderr, "ADIOI_GEN_WriteStrided_naive(%d):\n", __LINE__);*/ > ADIOI_GEN_WriteStrided_naive(fd, > buf, > count, > datatype, > file_ptr_type, > offset, > status, > error_code); > return; > } > /*FPRINTF(stderr, "%s(%d):\n",myname, __LINE__);*/ > > ADIOI_Datatype_iscontig(datatype, &buftype_is_contig); > ADIOI_Datatype_iscontig(fd->filetype, &filetype_is_contig); > > MPI_Type_size(fd->filetype, &filetype_size); > if ( ! filetype_size ) { > *error_code = MPI_SUCCESS; > return; > } > > MPI_Type_extent(fd->filetype, &filetype_extent); > MPI_Type_size(datatype, &buftype_size); > MPI_Type_extent(datatype, &buftype_extent); > etype_size = fd->etype_size; > > bufsize = buftype_size * count; > > /* get max_bufsize from the info object. */ > > value = (char *) ADIOI_Malloc((MPI_MAX_INFO_VAL+1)*sizeof(char)); > MPI_Info_get(fd->info, "ind_wr_buffer_size", MPI_MAX_INFO_VAL, value, > &info_flag); > max_bufsize = atoi(value); > ADIOI_Free(value); > > if (!buftype_is_contig && filetype_is_contig) { > > /* noncontiguous in memory, contiguous in file. */ > > ADIOI_Flatten_datatype(datatype); > flat_buf = ADIOI_Flatlist; > while (flat_buf->type != datatype) flat_buf = flat_buf->next; > > off = (file_ptr_type == ADIO_INDIVIDUAL) ? fd->fp_ind : > fd->disp + etype_size * offset; > > start_off = off; > end_offset = off + bufsize - 1; > writebuf_off = off; > writebuf = (char *) ADIOI_Malloc(max_bufsize); > writebuf_len = (int) (ADIOI_MIN(max_bufsize,end_offset-writebuf_off+1)); > > /* if atomicity is true, lock the region to be accessed */ > if (fd->atomicity) > ADIOI_WRITE_LOCK(fd, start_off, SEEK_SET, end_offset-start_off+1); > > for (j=0; j for (i=0; icount; i++) { > userbuf_off = j*buftype_extent + flat_buf->indices[i]; > req_off = off; > req_len = flat_buf->blocklens[i]; > ADIOI_BUFFERED_WRITE_WITHOUT_READ > off += flat_buf->blocklens[i]; > } > > /* write the buffer out finally */ > lseek(fd->fd_sys, writebuf_off, SEEK_SET); > if (!(fd->atomicity)) ADIOI_WRITE_LOCK(fd, writebuf_off, SEEK_SET, writebuf_len); > err = write(fd->fd_sys, writebuf, writebuf_len); > if (!(fd->atomicity)) ADIOI_UNLOCK(fd, writebuf_off, SEEK_SET, writebuf_len); > if (err == -1) err_flag = 1; > > if (fd->atomicity) > ADIOI_UNLOCK(fd, start_off, SEEK_SET, end_offset-start_off+1); > > ADIOI_Free(writebuf); /* malloced in the buffered_write macro */ > > if (file_ptr_type == ADIO_INDIVIDUAL) fd->fp_ind = off; > if (err_flag) { > *error_code = MPIO_Err_create_code(MPI_SUCCESS, > MPIR_ERR_RECOVERABLE, myname, > __LINE__, MPI_ERR_IO, "**io", > "**io %s", strerror(errno)); > } > else *error_code = MPI_SUCCESS; > } > > else { /* noncontiguous in file */ > > /* filetype already flattened in ADIO_Open */ > flat_file = ADIOI_Flatlist; > while (flat_file->type != fd->filetype) flat_file = flat_file->next; > disp = fd->disp; > > if (file_ptr_type == ADIO_INDIVIDUAL) { > offset = fd->fp_ind; /* in bytes */ > n_filetypes = -1; > flag = 0; > while (!flag) { > n_filetypes++; > for (i=0; icount; i++) { > if (disp + flat_file->indices[i] + > (ADIO_Offset) n_filetypes*filetype_extent + flat_file->blocklens[i] > >= offset) { > st_index = i; > fwr_size = (int) (disp + flat_file->indices[i] + > (ADIO_Offset) n_filetypes*filetype_extent > + flat_file->blocklens[i] - offset); > flag = 1; > break; > } > } > } > } > else { > n_etypes_in_filetype = filetype_size/etype_size; > n_filetypes = (int) (offset / n_etypes_in_filetype); > etype_in_filetype = (int) (offset % n_etypes_in_filetype); > size_in_filetype = etype_in_filetype * etype_size; > > sum = 0; > for (i=0; icount; i++) { > sum += flat_file->blocklens[i]; > if (sum > size_in_filetype) { > st_index = i; > fwr_size = sum - size_in_filetype; > abs_off_in_filetype = flat_file->indices[i] + > size_in_filetype - (sum - flat_file->blocklens[i]); > break; > } > } > > /* abs. offset in bytes in the file */ > offset = disp + (ADIO_Offset) n_filetypes*filetype_extent + abs_off_in_filetype; > } > > start_off = offset; > > /* Calculate end_offset, the last byte-offset that will be accessed. > e.g., if start_offset=0 and 100 bytes to be write, end_offset=99*/ > > st_fwr_size = fwr_size; > st_n_filetypes = n_filetypes; > i = 0; > j = st_index; > off = offset; > fwr_size = ADIOI_MIN(st_fwr_size, bufsize); > while (i < bufsize) { > i += fwr_size; > end_offset = off + fwr_size - 1; > > if (j < (flat_file->count - 1)) j++; > else { > j = 0; > n_filetypes++; > } > > off = disp + flat_file->indices[j] + (ADIO_Offset) n_filetypes*filetype_extent; > fwr_size = ADIOI_MIN(flat_file->blocklens[j], bufsize-i); > } > > /* if atomicity is true, lock the region to be accessed */ > if (fd->atomicity) > ADIOI_WRITE_LOCK(fd, start_off, SEEK_SET, end_offset-start_off+1); > > /* initial read for the read-modify-write */ > writebuf_off = offset; > writebuf = (char *) ADIOI_Malloc(max_bufsize); > writebuf_len = (int)(ADIOI_MIN(max_bufsize,end_offset-writebuf_off+1)); > if (!(fd->atomicity)) ADIOI_WRITE_LOCK(fd, writebuf_off, SEEK_SET, writebuf_len); > lseek(fd->fd_sys, writebuf_off, SEEK_SET); > err = read(fd->fd_sys, writebuf, writebuf_len); > if (err == -1) { > *error_code = MPIO_Err_create_code(MPI_SUCCESS, > MPIR_ERR_RECOVERABLE, > myname, __LINE__, > MPI_ERR_IO, > "ADIOI_BGL_WriteStrided: ROMIO tries to optimize this access by doing a read-modify-write, but is unable to read the file. Please give the file read permission and open it with MPI_MODE_RDWR.", 0); > return; > } > > if (buftype_is_contig && !filetype_is_contig) { > > /* contiguous in memory, noncontiguous in file. should be the most > common case. */ > > i = 0; > j = st_index; > off = offset; > n_filetypes = st_n_filetypes; > fwr_size = ADIOI_MIN(st_fwr_size, bufsize); > while (i < bufsize) { > if (fwr_size) { > /* TYPE_UB and TYPE_LB can result in > fwr_size = 0. save system call in such cases */ > /* lseek(fd->fd_sys, off, SEEK_SET); > err = write(fd->fd_sys, ((char *) buf) + i, fwr_size);*/ > > req_off = off; > req_len = fwr_size; > userbuf_off = i; > ADIOI_BUFFERED_WRITE > } > i += fwr_size; > > if (off + fwr_size < disp + flat_file->indices[j] + > flat_file->blocklens[j] + (ADIO_Offset) n_filetypes*filetype_extent) > off += fwr_size; > /* did not reach end of contiguous block in filetype. > no more I/O needed. off is incremented by fwr_size. */ > else { > if (j < (flat_file->count - 1)) j++; > else { > j = 0; > n_filetypes++; > } > off = disp + flat_file->indices[j] + > (ADIO_Offset) n_filetypes*filetype_extent; > fwr_size = ADIOI_MIN(flat_file->blocklens[j], bufsize-i); > } > } > } > else { > /* noncontiguous in memory as well as in file */ > > ADIOI_Flatten_datatype(datatype); > flat_buf = ADIOI_Flatlist; > while (flat_buf->type != datatype) flat_buf = flat_buf->next; > > k = num = buf_count = 0; > i = (int) (flat_buf->indices[0]); > j = st_index; > off = offset; > n_filetypes = st_n_filetypes; > fwr_size = st_fwr_size; > bwr_size = flat_buf->blocklens[0]; > > while (num < bufsize) { > size = ADIOI_MIN(fwr_size, bwr_size); > if (size) { > /* lseek(fd->fd_sys, off, SEEK_SET); > err = write(fd->fd_sys, ((char *) buf) + i, size); */ > > req_off = off; > req_len = size; > userbuf_off = i; > ADIOI_BUFFERED_WRITE > } > > new_fwr_size = fwr_size; > new_bwr_size = bwr_size; > > if (size == fwr_size) { > /* reached end of contiguous block in file */ > if (j < (flat_file->count - 1)) j++; > else { > j = 0; > n_filetypes++; > } > > off = disp + flat_file->indices[j] + > (ADIO_Offset) n_filetypes*filetype_extent; > > new_fwr_size = flat_file->blocklens[j]; > if (size != bwr_size) { > i += size; > new_bwr_size -= size; > } > } > > if (size == bwr_size) { > /* reached end of contiguous block in memory */ > > k = (k + 1)%flat_buf->count; > buf_count++; > i = (int) (buftype_extent*(buf_count/flat_buf->count) + > flat_buf->indices[k]); > new_bwr_size = flat_buf->blocklens[k]; > if (size != fwr_size) { > off += size; > new_fwr_size -= size; > } > } > num += size; > fwr_size = new_fwr_size; > bwr_size = new_bwr_size; > } > } > > /* write the buffer out finally */ > lseek(fd->fd_sys, writebuf_off, SEEK_SET); > if (!(fd->atomicity)) ADIOI_WRITE_LOCK(fd, writebuf_off, SEEK_SET, writebuf_len); > err = write(fd->fd_sys, writebuf, writebuf_len); > > if (!(fd->atomicity)) > ADIOI_UNLOCK(fd, writebuf_off, SEEK_SET, writebuf_len); > else ADIOI_UNLOCK(fd, start_off, SEEK_SET, end_offset-start_off+1); > > if (err == -1) err_flag = 1; > > ADIOI_Free(writebuf); /* malloced in the buffered_write macro */ > > if (file_ptr_type == ADIO_INDIVIDUAL) fd->fp_ind = off; > if (err_flag) { > *error_code = MPIO_Err_create_code(MPI_SUCCESS, > MPIR_ERR_RECOVERABLE, myname, > __LINE__, MPI_ERR_IO, "**io", > "**io %s", strerror(errno)); > } > else *error_code = MPI_SUCCESS; > } > > fd->fp_sys_posn = -1; /* set it to null. */ > > #ifdef HAVE_STATUS_SET_BYTES > MPIR_Status_set_bytes(status, datatype, bufsize); > /* This is a temporary way of filling in status. The right way is to > keep track of how much data was actually written by ADIOI_BUFFERED_WRITE. */ > #endif > > if (!buftype_is_contig) ADIOI_Delete_flattened(datatype); > } diff -rN mpich2-1.0.7rc1/src/mpi/romio/adio/ad_bgl/.cvsignore bgp-mpich2/src/mpi/romio/adio/ad_bgl/.cvsignore 0a1 > .state-cache diff -rN mpich2-1.0.7rc1/src/mpi/romio/adio/ad_bgl/Makefile.in bgp-mpich2/src/mpi/romio/adio/ad_bgl/Makefile.in 0a1,47 > CC = @CC@ > AR = @AR@ > LIBNAME = @LIBNAME@ > srcdir = @srcdir@ > CC_SHL = @CC_SHL@ > SHLIBNAME = @SHLIBNAME@ > > INCLUDE_DIR = -I@MPI_INCLUDE_DIR@ -I${srcdir}/../include -I../include -I../../include -I${srcdir}/../../../../include -I../../../../include @CPPFLAGS@ > CFLAGS = @CFLAGS@ $(INCLUDE_DIR) -DBGL_OPTIM_STEP1_2=1 -DBGL_OPTIM_STEP1_1=1 > > C_COMPILE_SHL = $(CC_SHL) @CFLAGS@ $(INCLUDE_DIR) > > @VPATH@ > > AD_BGL_OBJECTS = \ > ad_bgl_open.o ad_bgl_close.o \ > ad_bgl_fcntl.o \ > ad_bgl_read.o ad_bgl_write.o ad_bgl_getsh.o ad_bgl_setsh.o \ > ad_bgl.o ad_bgl_aggrs.o ad_bgl_pset.o ad_bgl_hints.o \ > ad_bgl_rdcoll.o ad_bgl_wrcoll.o ad_bgl_tuning.o > > default: $(LIBNAME) > @if [ "@ENABLE_SHLIB@" != "none" ] ; then \ > $(MAKE) $(SHLIBNAME).la ;\ > fi > > .SUFFIXES: $(SUFFIXES) .p .lo > > .c.o: > $(CC) $(CFLAGS) -c $< > .c.lo: > $(C_COMPILE_SHL) -c $< > @mv -f $*.o $*.lo > > $(LIBNAME): $(AD_BGL_OBJECTS) > $(AR) $(LIBNAME) $(AD_BGL_OBJECTS) > > AD_BGL_LOOBJECTS=$(AD_BGL_OBJECTS:.o=.lo) > $(SHLIBNAME).la: $(AD_BGL_LOOBJECTS) > $(AR) $(SHLIBNAME).la $(AD_BGL_LOOBJECTS) > > coverage: > -@for file in ${AD_BGL_OBJECTS:.o=.c} ; do \ > gcov -b -f $$file ; done > > clean: > @rm -f *.o *.lo diff -rN mpich2-1.0.7rc1/src/mpi/romio/adio/ad_testfs/ad_testfs_hints.c bgp-mpich2/src/mpi/romio/adio/ad_testfs/ad_testfs_hints.c 9a10 > #include "../ad_bgl/ad_bgl.h" 23a25,28 > #ifdef ROMIO_BGL /* BlueGene support for pvfs through ufs */ > /* BlueGene hack: force testfs to mimic BlueGene hints */ > ADIOI_BGL_SetInfo(fd, users_info, error_code); > #else 24a30 > #endif diff -rN mpich2-1.0.7rc1/src/mpi/romio/adio/ad_ufs/ad_ufs.c bgp-mpich2/src/mpi/romio/adio/ad_ufs/ad_ufs.c 8a9 > #include "../ad_bgl/ad_bgl.h" 13a15,17 > #ifdef ROMIO_BGL /* BlueGene support for pvfs through ufs */ > ADIOI_BGL_Open, /* Open */ > #else 14a19 > #endif 16a22,25 > #ifdef ROMIO_BGL /* BlueGene support for pvfs through ufs */ > ADIOI_BGL_ReadStridedColl, /* ReadStridedColl */ > ADIOI_BGL_WriteStridedColl, /* WriteStridedColl */ > #else 18a28 > #endif 20a31,36 > #ifdef ROMIO_BGL /* BlueGene support for pvfs through ufs */ > ADIOI_BGL_SetInfo, /* SetInfo */ > ADIOI_GEN_ReadStrided, /* ReadStrided */ > ADIOI_NOLOCK_WriteStrided, /* WriteStrided */ > ADIOI_BGL_Close, /* Close */ > #else 24a41 > #endif diff -rN mpich2-1.0.7rc1/src/mpi/romio/adio/common/ad_close.c bgp-mpich2/src/mpi/romio/adio/common/ad_close.c 64,66c64,67 < ADIOI_Free(fd->hints->ranklist); < ADIOI_Free(fd->hints->cb_config_list); < ADIOI_Free(fd->hints); --- > if (fd->hints && fd->hints->ranklist) ADIOI_Free(fd->hints->ranklist); > if (fd->hints && fd->hints->cb_config_list) ADIOI_Free(fd->hints->cb_config_list); > if (fd->hints) ADIOI_Free(fd->hints); > // if (fd->fns) ADIOI_Free(fd->fns); diff -rN mpich2-1.0.7rc1/src/mpi/romio/adio/common/ad_fstype.c bgp-mpich2/src/mpi/romio/adio/common/ad_fstype.c 198a199,221 > #ifdef ROMIO_BGL /* BlueGene support for pvfs through ufs */ > static void check_for_pvfs_exception(char *filename, int *fstype) > { > /* exception for lockless PVFS file system */ > int err; > struct statfs fsbuf; > char *dir; > > do { > err = statfs(filename, &fsbuf); > } while (err && (errno == ESTALE)); > > if (err && (errno == ENOENT)) { > ADIO_FileSysType_parentdir(filename, &dir); > err = statfs(dir, &fsbuf); > ADIOI_Free(dir); > } > /* 2030528: magic number for pvfs, but we might not have pvfs header files > * in this environment */ > if (fsbuf.f_type == 20030528) > *fstype = ADIO_UFS; /* use ad_ufs on bluegene to support pvfs */ > } > #endif 217a241,252 > > /*------------------------------------------------------------- > quick fix to support using file name withnot prefix 'bgl:' > -------------------------------------------------------------*/ > #ifdef ROMIO_BGL > *fstype = ADIO_BGL; > check_for_pvfs_exception(filename, fstype); > *error_code = MPI_SUCCESS; > return; > #endif /* ROMIO_BGL */ > /*-------------------------------------------------------------*/ > 469a505,507 > else if (!strncmp(filename, "bgl:", 4) || !strncmp(filename, "BGL:", 4)) { > *fstype = ADIO_BGL; > } 673a712,722 > if (file_system == ADIO_BGL) { > #ifndef ROMIO_BGL > *error_code = MPIR_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, > myname, __LINE__, MPI_ERR_IO, > "**iofstypeunsupported", 0); > return; > #else > *ops = &ADIO_BGL_operations; > #endif > } > diff -rN mpich2-1.0.7rc1/src/mpi/romio/adio/common/ad_get_sh_fp.c bgp-mpich2/src/mpi/romio/adio/common/ad_get_sh_fp.c 30a31,37 > #ifdef ROMIO_BGL > if (fd->file_system == ADIO_BGL) { > ADIOI_BGL_Get_shared_fp(fd, incr, shared_fp, error_code); > return; > } > #endif > diff -rN mpich2-1.0.7rc1/src/mpi/romio/adio/common/ad_open.c bgp-mpich2/src/mpi/romio/adio/common/ad_open.c 80d79 < 95a95,97 > MPI_Comm_rank(comm, &rank); > > #if !BGL_OPTIM_STEP1_1 /* removed by Hao */ 106d107 < MPI_Comm_rank(comm, &rank); 140a142 > #endif /* removed by Hao */ diff -rN mpich2-1.0.7rc1/src/mpi/romio/adio/common/ad_read_coll.c bgp-mpich2/src/mpi/romio/adio/common/ad_read_coll.c 329a330,337 > /* > int ii; > printf( "flattened %3d : ", flat_file->count ); > for (ii=0; iicount; ii++) { > printf( "%16qd:%-12d", flat_file->indices[ii], flat_file->blocklens[ii] ); > } > printf( "\n" ); > */ 405a414,415 > ADIO_Offset min_off = 1048576; min_off *= (1048576*1024); > ADIO_Offset max_off = 0; 409a420,421 > min_off = ( min_off > offset_list[k] ? offset_list[k] : min_off ); > max_off = ( max_off < (offset_list[k] + len_list[k] - 1) ? (offset_list[k] + len_list[k] - 1) : max_off ); 446c458,460 < *end_offset_ptr = end_offset; --- > // *end_offset_ptr = end_offset; > *start_offset_ptr = min_off; > *end_offset_ptr = max_off; diff -rN mpich2-1.0.7rc1/src/mpi/romio/adio/common/ad_set_sh_fp.c bgp-mpich2/src/mpi/romio/adio/common/ad_set_sh_fp.c 25a26,32 > #ifdef ROMIO_BGL > if (fd->file_system == ADIO_BGL) { > ADIOI_BGL_Set_shared_fp(fd, offset, error_code); > return; > } > #endif > diff -rN mpich2-1.0.7rc1/src/mpi/romio/adio/common/ad_write_nolock.c bgp-mpich2/src/mpi/romio/adio/common/ad_write_nolock.c 0a1,364 > /* -*- Mode: C; c-basic-offset:4 ; -*- */ > /* > * > * Copyright (C) 1997 University of Chicago. > * See COPYRIGHT notice in top-level directory. > */ > > #define _XOPEN_SOURCE 500 /* for pwrite (saves an lseek system call) */ > #include > > #include "adio.h" > #include "adio_extern.h" > > > /* #define IO_DEBUG 1 */ > void ADIOI_NOLOCK_WriteStrided(ADIO_File fd, void *buf, int count, > MPI_Datatype datatype, int file_ptr_type, > ADIO_Offset offset, ADIO_Status *status, int > *error_code) > { > /* borrowed from old-school PVFS (v1) code. A driver for file systems that > * cannot or do not support client-side buffering > * Does not do data sieving optimization > * Does contain write-combining optimization for noncontig in memory, contig in > * file > */ > > /* offset is in units of etype relative to the filetype. */ > > ADIOI_Flatlist_node *flat_buf, *flat_file; > int i, j, k, err=-1, bwr_size, fwr_size=0, st_index=0; > int bufsize, num, size, sum, n_etypes_in_filetype, size_in_filetype; > int n_filetypes, etype_in_filetype; > ADIO_Offset abs_off_in_filetype=0; > int filetype_size, etype_size, buftype_size; > MPI_Aint filetype_extent, buftype_extent, indx; > int buf_count, buftype_is_contig, filetype_is_contig; > ADIO_Offset off, disp; > int flag, new_bwr_size, new_fwr_size, err_flag=0; > static char myname[] = "ADIOI_PVFS_WRITESTRIDED"; > #ifdef IO_DEBUG > int rank,nprocs; > #endif > > /* --BEGIN ERROR HANDLING-- */ > if (fd->atomicity) { > *error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, > myname, __LINE__, > MPI_ERR_INTERN, > "Atomic mode set in I/O function", 0); > return; > } > /* --END ERROR HANDLING-- */ > > ADIOI_Datatype_iscontig(datatype, &buftype_is_contig); > ADIOI_Datatype_iscontig(fd->filetype, &filetype_is_contig); > > MPI_Type_size(fd->filetype, &filetype_size); > if ( ! filetype_size ) { > *error_code = MPI_SUCCESS; > return; > } > > #ifdef IO_DEBUG > MPI_Comm_rank(fd->comm, &rank); > MPI_Comm_size(fd->comm, &nprocs); > #endif > > MPI_Type_extent(fd->filetype, &filetype_extent); > MPI_Type_size(datatype, &buftype_size); > MPI_Type_extent(datatype, &buftype_extent); > etype_size = fd->etype_size; > > bufsize = buftype_size * count; > > if (!buftype_is_contig && filetype_is_contig) { > char *combine_buf, *combine_buf_ptr; > ADIO_Offset combine_buf_remain; > /* noncontiguous in memory, contiguous in file. use writev */ > > ADIOI_Flatten_datatype(datatype); > flat_buf = ADIOI_Flatlist; > while (flat_buf->type != datatype) flat_buf = flat_buf->next; > > /* allocate our "combine buffer" to pack data into before writing */ > combine_buf = (char *) ADIOI_Malloc(fd->hints->ind_wr_buffer_size); > combine_buf_ptr = combine_buf; > combine_buf_remain = fd->hints->ind_wr_buffer_size; > > /* seek to the right spot in the file */ > if (file_ptr_type == ADIO_EXPLICIT_OFFSET) { > off = fd->disp + etype_size * offset; > lseek64(fd->fd_sys, off, SEEK_SET); > } > else off = lseek64(fd->fd_sys, fd->fp_ind, SEEK_SET); > > /* loop through all the flattened pieces. combine into buffer until > * no more will fit, then write. > * > * special case of a given piece being bigger than the combine buffer > * is also handled. > */ > for (j=0; j for (i=0; icount; i++) { > if (flat_buf->blocklens[i] > combine_buf_remain && combine_buf != combine_buf_ptr) { > /* there is data in the buffer; write out the buffer so far */ > #ifdef IO_DEBUG > printf("[%d/%d] nc mem c file (0) writing loc = %Ld sz = %Ld\n", > rank, nprocs, off, > fd->hints->ind_wr_buffer_size-combine_buf_remain); > #endif > err = write(fd->fd_sys, > combine_buf, > fd->hints->ind_wr_buffer_size - combine_buf_remain); > if (err == -1) err_flag = 1; > > /* reset our buffer info */ > combine_buf_ptr = combine_buf; > combine_buf_remain = fd->hints->ind_wr_buffer_size; > } > > /* TODO: heuristic for when to not bother to use combine buffer? */ > if (flat_buf->blocklens[i] >= combine_buf_remain) { > /* special case: blocklen is as big as or bigger than the combine buf; > * write directly > */ > #ifdef IO_DEBUG > printf("[%d/%d] nc mem c file (1) writing loc = %Ld sz = %d\n", > rank, nprocs, off, > flat_buf->blocklens[i]); > #endif > err = write(fd->fd_sys, > ((char *) buf) + j*buftype_extent + flat_buf->indices[i], > flat_buf->blocklens[i]); > if (err == -1) err_flag = 1; > off += flat_buf->blocklens[i]; /* keep up with the final file offset too */ > } > else { > /* copy more data into combine buffer */ > memcpy(combine_buf_ptr, > ((char *) buf) + j*buftype_extent + flat_buf->indices[i], > flat_buf->blocklens[i]); > combine_buf_ptr += flat_buf->blocklens[i]; > combine_buf_remain -= flat_buf->blocklens[i]; > off += flat_buf->blocklens[i]; /* keep up with the final file offset too */ > } > } > } > > if (combine_buf_ptr != combine_buf) { > /* data left in buffer to write */ > #ifdef IO_DEBUG > printf("[%d/%d] nc mem c file (2) writing loc = %Ld sz = %Ld\n", > rank, nprocs, off, > fd->hints->ind_wr_buffer_size-combine_buf_remain); > #endif > err = write(fd->fd_sys, > combine_buf, > fd->hints->ind_wr_buffer_size - combine_buf_remain); > if (err == -1) err_flag = 1; > } > > if (file_ptr_type == ADIO_INDIVIDUAL) fd->fp_ind = off; > > ADIOI_Free(combine_buf); > > if (err_flag) { > *error_code = MPIO_Err_create_code(MPI_SUCCESS, > MPIR_ERR_RECOVERABLE, myname, > __LINE__, MPI_ERR_IO, "**io", > "**io %s", strerror(errno)); > } > else *error_code = MPI_SUCCESS; > } /* if (!buftype_is_contig && filetype_is_contig) ... */ > > else { /* noncontiguous in file */ > > /* split up into several contiguous writes */ > > /* find starting location in the file */ > > /* filetype already flattened in ADIO_Open */ > flat_file = ADIOI_Flatlist; > while (flat_file->type != fd->filetype) flat_file = flat_file->next; > disp = fd->disp; > > if (file_ptr_type == ADIO_INDIVIDUAL) { > offset = fd->fp_ind; /* in bytes */ > n_filetypes = -1; > flag = 0; > while (!flag) { > n_filetypes++; > for (i=0; icount; i++) { > if (disp + flat_file->indices[i] + > (ADIO_Offset) n_filetypes*filetype_extent + flat_file->blocklens[i] > >= offset) { > st_index = i; > fwr_size = disp + flat_file->indices[i] + > (ADIO_Offset) n_filetypes*filetype_extent > + flat_file->blocklens[i] - offset; > flag = 1; > break; > } > } > } > } > else { > n_etypes_in_filetype = filetype_size/etype_size; > n_filetypes = (int) (offset / n_etypes_in_filetype); > etype_in_filetype = (int) (offset % n_etypes_in_filetype); > size_in_filetype = etype_in_filetype * etype_size; > > sum = 0; > for (i=0; icount; i++) { > sum += flat_file->blocklens[i]; > if (sum > size_in_filetype) { > st_index = i; > fwr_size = sum - size_in_filetype; > abs_off_in_filetype = flat_file->indices[i] + > size_in_filetype - (sum - flat_file->blocklens[i]); > break; > } > } > > /* abs. offset in bytes in the file */ > offset = disp + (ADIO_Offset) n_filetypes*filetype_extent + abs_off_in_filetype; > } > > if (buftype_is_contig && !filetype_is_contig) { > > /* contiguous in memory, noncontiguous in file. should be the most > common case. */ > > i = 0; > j = st_index; > off = offset; > fwr_size = ADIOI_MIN(fwr_size, bufsize); > while (i < bufsize) { > if (fwr_size) { > /* TYPE_UB and TYPE_LB can result in > fwr_size = 0. save system call in such cases */ > #ifdef PROFILE > MPE_Log_event(5, 0, "start write"); > #endif > #ifdef IO_DEBUG > printf("[%d/%d] c mem nc file writing loc = %Ld sz = %d\n", > rank, nprocs, off, > fwr_size); > #endif > err = pwrite(fd->fd_sys, ((char *) buf) + i, fwr_size, off); > #ifdef PROFILE > MPE_Log_event(6, 0, "end write"); > #endif > if (err == -1) err_flag = 1; > } > i += fwr_size; > > if (off + fwr_size < disp + flat_file->indices[j] + > flat_file->blocklens[j] + (ADIO_Offset) n_filetypes*filetype_extent) > off += fwr_size; > /* did not reach end of contiguous block in filetype. > no more I/O needed. off is incremented by fwr_size. */ > else { > if (j < (flat_file->count - 1)) j++; > else { > j = 0; > n_filetypes++; > } > off = disp + flat_file->indices[j] + > (ADIO_Offset) n_filetypes*filetype_extent; > fwr_size = ADIOI_MIN(flat_file->blocklens[j], bufsize-i); > } > } > } > else { > /* noncontiguous in memory as well as in file */ > > ADIOI_Flatten_datatype(datatype); > flat_buf = ADIOI_Flatlist; > while (flat_buf->type != datatype) flat_buf = flat_buf->next; > > k = num = buf_count = 0; > indx = flat_buf->indices[0]; > j = st_index; > off = offset; > bwr_size = flat_buf->blocklens[0]; > > while (num < bufsize) { > size = ADIOI_MIN(fwr_size, bwr_size); > if (size) { > #ifdef PROFILE > MPE_Log_event(5, 0, "start write"); > #endif > #ifdef IO_DEBUG > printf("[%d/%d] nc mem nc file writing loc = %Ld sz = %d\n", > rank, nprocs, off, size); > #endif > err = pwrite(fd->fd_sys, ((char *) buf) + indx, size, off); > #ifdef PROFILE > MPE_Log_event(6, 0, "end write"); > #endif > if (err == -1) err_flag = 1; > } > > new_fwr_size = fwr_size; > new_bwr_size = bwr_size; > > if (size == fwr_size) { > /* reached end of contiguous block in file */ > if (j < (flat_file->count - 1)) j++; > else { > j = 0; > n_filetypes++; > } > > off = disp + flat_file->indices[j] + > (ADIO_Offset) n_filetypes*filetype_extent; > > new_fwr_size = flat_file->blocklens[j]; > if (size != bwr_size) { > indx += size; > new_bwr_size -= size; > } > } > > if (size == bwr_size) { > /* reached end of contiguous block in memory */ > > k = (k + 1)%flat_buf->count; > buf_count++; > indx = buftype_extent*(buf_count/flat_buf->count) + > flat_buf->indices[k]; > new_bwr_size = flat_buf->blocklens[k]; > if (size != fwr_size) { > off += size; > new_fwr_size -= size; > } > } > num += size; > fwr_size = new_fwr_size; > bwr_size = new_bwr_size; > } > } > > if (file_ptr_type == ADIO_INDIVIDUAL) fd->fp_ind = off; > if (err_flag) { > *error_code = MPIO_Err_create_code(MPI_SUCCESS, > MPIR_ERR_RECOVERABLE, myname, > __LINE__, MPI_ERR_IO, "**io", > "**io %s", strerror(errno)); > } > else *error_code = MPI_SUCCESS; > } > > fd->fp_sys_posn = -1; /* set it to null. */ > > #ifdef HAVE_STATUS_SET_BYTES > MPIR_Status_set_bytes(status, datatype, bufsize); > /* This is a temporary way of filling in status. The right way is to > keep track of how much data was actually written by ADIOI_BUFFERED_WRITE. */ > #endif > > if (!buftype_is_contig) ADIOI_Delete_flattened(datatype); > } diff -rN mpich2-1.0.7rc1/src/mpi/romio/adio/common/cb_config_list.c bgp-mpich2/src/mpi/romio/adio/common/cb_config_list.c 70a71 > /* printf( "\tHao, ADIOI_cb_bcast_rank_map, cb_nodes = %d\n", fd->hints->cb_nodes ); */ 688c689,690 < slen = (int)strcspn(token_ptr, ":,"); --- > /* slen = (int)strcspn(token_ptr, ":,"); */ > slen = (int)strcspn(token_ptr, ":;"); 694c696,697 < if (*token_ptr == ',') { --- > /* if (*token_ptr == ',') { */ > if (*token_ptr == ';') { diff -rN mpich2-1.0.7rc1/src/mpi/romio/adio/common/flatten.c bgp-mpich2/src/mpi/romio/adio/common/flatten.c 15a16,27 > #define COMPILE_TIME_ASSERT(expr) switch(0){case 0:case expr:;} > static inline void flatten_compile_time_assert () > { > /* > * Assert that the size of the MPI_Aint typedef is equal to an unsigned. > * We used unsigned for addresses to avoid negative addresses, but since > * it's an array of addresses passed as MPI_Aint's, they'd better be the > * same size. > */ > COMPILE_TIME_ASSERT(sizeof(MPI_Aint)==sizeof(unsigned)); > } > 110c122 < MPI_Aint *adds; --- > unsigned *adds; // used to be MPI_Aint - see flatten_compile_time_assert() 115c127 < adds = (MPI_Aint *) ADIOI_Malloc((nadds+1)*sizeof(MPI_Aint)); --- > adds = (unsigned *) ADIOI_Malloc((nadds+1)*sizeof(MPI_Aint)); 117c129 < MPI_Type_get_contents(datatype, nints, nadds, ntypes, ints, adds, types); --- > MPI_Type_get_contents(datatype, nints, nadds, ntypes, ints, (MPI_Aint*)adds, types); 259a272 > case MPI_COMBINER_HVECTOR_INTEGER: 373a387,437 > case MPI_COMBINER_INDEXED_BLOCK: > top_count = ints[0]; > MPI_Type_get_envelope(types[0], &old_nints, &old_nadds, > &old_ntypes, &old_combiner); > ADIOI_Datatype_iscontig(types[0], &old_is_contig); > MPI_Type_extent(types[0], &old_extent); > > prev_index = *curr_index; > if ((old_combiner != MPI_COMBINER_NAMED) && (!old_is_contig)) > ADIOI_Flatten(types[0], flat, > st_offset+ints[1+1]*old_extent, curr_index); > > if (prev_index == *curr_index) { > /* simplest case, indexed type made up of basic or contiguous types */ > j = *curr_index; > for (i=j; i flat->indices[i] = st_offset + ints[1+1+i-j]*old_extent; > flat->blocklens[i] = (int) (ints[1]*old_extent); > } > *curr_index = i; > } > else { > /* vector of noncontiguous derived types */ > > j = *curr_index; > num = *curr_index - prev_index; > > /* The noncontiguous types have to be replicated blocklens[i] times > and then strided. Replicate the first one. */ > for (m=1; m for (i=0; i flat->indices[j] = flat->indices[j-num] + old_extent; > flat->blocklens[j] = flat->blocklens[j-num]; > j++; > } > } > *curr_index = j; > > /* Now repeat with strides. */ > num = *curr_index - prev_index; > for (i=1; i for (m=0; m flat->indices[j] = flat->indices[j-num] + (ints[2+i]-ints[1+i])*old_extent; > flat->blocklens[j] = flat->blocklens[j-num]; > j++; > } > } > *curr_index = j; > } > break; > 374a439 > case MPI_COMBINER_HINDEXED_INTEGER: 435a501 > case MPI_COMBINER_STRUCT_INTEGER: 610a677 > case MPI_COMBINER_HVECTOR_INTEGER: 644a712 > case MPI_COMBINER_HINDEXED_INTEGER: 676a745,775 > case MPI_COMBINER_INDEXED_BLOCK: > top_count = ints[0]; > MPI_Type_get_envelope(types[0], &old_nints, &old_nadds, > &old_ntypes, &old_combiner); > ADIOI_Datatype_iscontig(types[0], &old_is_contig); > > prev_index = *curr_index; > if ((old_combiner != MPI_COMBINER_NAMED) && (!old_is_contig)) > count = ADIOI_Count_contiguous_blocks(types[0], curr_index); > else count = 1; > > if (prev_index == *curr_index) { > /* simplest case, indexed type made up of basic or contiguous types */ > count = top_count; > *curr_index += count; > } > else { > /* indexed type made up of noncontiguous derived types */ > basic_num = *curr_index - prev_index; > > /* The noncontiguous types have to be replicated blocklens[i] times > and then strided. */ > *curr_index += (ints[1]-1) * basic_num; > count *= ints[1]; > > /* Now repeat with strides. */ > *curr_index += (top_count-1) * count; > count *= top_count; > } > break; > 677a777 > case MPI_COMBINER_STRUCT_INTEGER: 706c806 < FPRINTF(stderr, "Error: Unsupported datatype passed to ADIOI_Count_contiguous_blocks\n"); --- > FPRINTF(stderr, "Error: Unsupported datatype passed to ADIOI_Count_contiguous_blocks, combiner = %d\n", combiner); diff -rN mpich2-1.0.7rc1/src/mpi/romio/adio/common/lock.c bgp-mpich2/src/mpi/romio/adio/common/lock.c 122a123 > errno = 0; 130c131,147 < FPRINTF(stderr, "File locking failed in ADIOI_Set_lock. If the file system is NFS, you need to use NFS version 3, ensure that the lockd daemon is running on all the machines, and mount the directory with the 'noac' option (no attribute caching).\n"); --- > fprintf(stderr, "File locking failed in ADIOI_Set_lock(fd %X,cmd %s/%X,type %s/%X,whence %X) with return value %X and errno %X.\n" > "If the file system is NFS, you need to use NFS version 3, ensure that the lockd daemon is running on all the machines, and mount the directory with the 'noac' option (no attribute caching).\n", > fd, > ((cmd == F_GETLK )? "F_GETLK" : > ((cmd == F_SETLK )? "F_SETLK" : > ((cmd == F_SETLKW )? "F_SETLKW" : > ((cmd == F_GETLK64 )? "F_GETLK64" : > ((cmd == F_SETLK64 )? "F_SETLK64" : > ((cmd == F_SETLKW64)? "F_SETLKW64" : "UNEXPECTED")))))), > cmd, > ((type == F_RDLCK )? "F_RDLCK" : > ((type == F_WRLCK )? "F_WRLCK" : > ((type == F_UNLCK )? "F_UNLOCK" : "UNEXPECTED"))), > type, > whence, err, errno); > perror("ADIOI_Set_lock:"); > fprintf(stderr,"ADIOI_Set_lock:offset %llu, length %llu\n",(unsigned long long)offset, (unsigned long long)len); 159c176,192 < FPRINTF(stderr, "File locking failed in ADIOI_Set_lock64\n"); --- > fprintf(stderr, "File locking failed in ADIOI_Set_lock64(fd %X,cmd %s/%X,type %s/%X,whence %X) with return value %X and errno %X.\n" > "If the file system is NFS, you need to use NFS version 3, ensure that the lockd daemon is running on all the machines, and mount the directory with the 'noac' option (no attribute caching).\n", > fd, > ((cmd == F_GETLK )? "F_GETLK" : > ((cmd == F_SETLK )? "F_SETLK" : > ((cmd == F_SETLKW )? "F_SETLKW" : > ((cmd == F_GETLK64 )? "F_GETLK64" : > ((cmd == F_SETLK64 )? "F_SETLK64" : > ((cmd == F_SETLKW64)? "F_SETLKW64" : "UNEXPECTED")))))), > cmd, > ((type == F_RDLCK )? "F_RDLCK" : > ((type == F_WRLCK )? "F_WRLCK" : > ((type == F_UNLCK )? "F_UNLOCK" : "UNEXPECTED"))), > type, > whence, err, errno); > perror("ADIOI_Set_lock64:"); > fprintf(stderr,"ADIOI_Set_lock:offset %llu, length %llu\n",(unsigned long long)offset, (unsigned long long)len); diff -rN mpich2-1.0.7rc1/src/mpi/romio/adio/common/Makefile.in bgp-mpich2/src/mpi/romio/adio/common/Makefile.in 13c13 < CFLAGS = @CPPFLAGS@ @CFLAGS@ $(INCLUDE_DIR) --- > CFLAGS = @CPPFLAGS@ @CFLAGS@ $(INCLUDE_DIR) -DBGL_OPTIM_STEP1_1=1 31c31 < ad_subarray.o ad_darray.o strfns.o greq_fns.o system_hints.o --- > ad_subarray.o ad_darray.o strfns.o greq_fns.o system_hints.o ad_write_nolock.o diff -rN mpich2-1.0.7rc1/src/mpi/romio/adio/include/adio.h bgp-mpich2/src/mpi/romio/adio/include/adio.h 291a292,293 > #define ADIO_BGL 163 /* IBM BGL */ > diff -rN mpich2-1.0.7rc1/src/mpi/romio/adio/include/adioi_errmsg.h bgp-mpich2/src/mpi/romio/adio/include/adioi_errmsg.h 64a65 > MPIR_ERR_NO_BGL "ROMIO has not been configured to use the BGL file system" diff -rN mpich2-1.0.7rc1/src/mpi/romio/adio/include/adioi_fs_proto.h bgp-mpich2/src/mpi/romio/adio/include/adioi_fs_proto.h 71a72,77 > /* Added by yuh (same as for UFS) */ > #ifdef ROMIO_BGL > extern struct ADIOI_Fns_struct ADIO_BGL_operations; > /* prototypes are in adio/ad_ufs/ad_bgl.h */ > #endif > diff -rN mpich2-1.0.7rc1/src/mpi/romio/adio/include/adioi.h bgp-mpich2/src/mpi/romio/adio/include/adioi.h 359a360,363 > void ADIOI_NOLOCK_WriteStrided(ADIO_File fd, void *buf, int count, > MPI_Datatype datatype, int file_ptr_type, > ADIO_Offset offset, ADIO_Status *status, int > *error_code); diff -rN mpich2-1.0.7rc1/src/mpi/romio/adio/include/mpio_error.h bgp-mpich2/src/mpi/romio/adio/include/mpio_error.h 65a66 > #define MPIR_ERR_NO_BGL 38 diff -rN mpich2-1.0.7rc1/src/mpi/romio/configure.in bgp-mpich2/src/mpi/romio/configure.in 96c96 < known_filesystems="nfs ufs pfs pvfs pvfs2 testfs xfs panfs gridftp" --- > known_filesystems="nfs ufs pfs pvfs pvfs2 testfs xfs panfs gridftp bgl" 415a416 > 430c431,437 < --- > # set cross compilation setting -- Hao Yu > AC_MSG_RESULT([set cross compilation to yes]) > cross_compiling=yes > ac_cv_prog_cc_cross=yes > ac_cv_prog_f77_cross=yes > ac_cv_prog_f90_cross=yes > ac_cv_prog_cxx_cross=yes 1089a1097,1099 > if test -n "$file_system_bgl"; then # added for bgl -- Hao Yu > AC_DEFINE(ROMIO_BGL,1,[Define for ROMIO with BGL]) > fi 1220a1231,1234 > if test -n "$file_system_bgl"; then > SYSDEP_INC=-I${prefix}/include > else > SYSDEP_INC= 1556a1571 > fi 1989a2005,2024 > AC_CHECK_HEADERS(unistd.h, > AC_MSG_CHECKING([for large file defines]) > AC_TRY_COMPILE([ > #include > ], [ > #ifndef _LFS64_LARGEFILE > #error no largefile defines > #endif > ], > CFLAGS="${CFLAGS} -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64" > AC_MSG_RESULT(yes), > AC_MSG_RESULT(none) ) > ) > > # for BGL, always support large file -- Hao Yu > CFLAGS="${CFLAGS} -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64" > > echo "setting SYSDEP_INC to $SYSDEP_INC" > AC_SUBST(SYSDEP_INC) > 2101a2137 > adio/ad_bgl/Makefile \ diff -rN mpich2-1.0.7rc1/src/mpi/romio/Makefile.in bgp-mpich2/src/mpi/romio/Makefile.in 18c18 < ALL_DIRS = mpi-io mpi-io/fortran mpi2-other/info mpi2-other/info/fortran mpi2-other/array mpi2-other/array/fortran adio/common adio/ad_pfs adio/ad_piofs adio/ad_nfs adio/ad_ufs adio/ad_xfs adio/ad_hfs adio/ad_sfs adio/ad_testfs adio/ad_pvfs adio/ad_pvfs2 adio/ad_panfs adio/ad_gridftp test mpi-io/glue/default mpi-io/glue/mpich1 mpi-io/glue/mpich2 --- > ALL_DIRS = mpi-io mpi-io/fortran mpi2-other/info mpi2-other/info/fortran mpi2-other/array mpi2-other/array/fortran adio/common adio/ad_pfs adio/ad_piofs adio/ad_nfs adio/ad_ufs adio/ad_xfs adio/ad_hfs adio/ad_sfs adio/ad_testfs adio/ad_pvfs adio/ad_pvfs2 adio/ad_panfs adio/ad_gridftp test mpi-io/glue/default mpi-io/glue/mpich1 mpi-io/glue/mpich2 adio/ad_bgl diff -rN mpich2-1.0.7rc1/src/mpi/romio/mpi2-other/info/fortran/Makefile.in bgp-mpich2/src/mpi/romio/mpi2-other/info/fortran/Makefile.in 1c1 < CC = @CC@ --- > diff -rN mpich2-1.0.7rc1/src/mpi/romio/mpi-io/get_amode.c bgp-mpich2/src/mpi/romio/mpi-io/get_amode.c 39c39 < int error_code=MPI_SUCCESS; --- > int error_code = MPI_SUCCESS; diff -rN mpich2-1.0.7rc1/src/mpi/romio/test/file_info.c bgp-mpich2/src/mpi/romio/test/file_info.c 5a6,9 > > /* Change for BG/L made by Hao Yu, yuh@us.ibm.com > */ > 10a15,28 > #define ON_BGL 1 > #if ON_BGL > # define DFLT_CB_BUFFER_SIZE 16777216 > # define DFLT_IND_RD_BUFFER_SIZE 4194304 > # define DFLT_IND_WR_BUFFER_SIZE 4194304 > # define DFLT_ROMIO_CB_READ "enable" > # define DFLT_ROMIO_CB_WRITE "enable" > #else > # define DFLT_CB_BUFFER_SIZE 16777216 > # define DFLT_IND_RD_BUFFER_SIZE 4194304 > # define DFLT_IND_WR_BUFFER_SIZE 524288 > # define DFLT_ROMIO_CB_READ "automatic" > # define DFLT_ROMIO_CB_WRITE "automatic" > #endif 77c95 < if (atoi(value) != 16777216) { --- > if (atoi(value) != DFLT_CB_BUFFER_SIZE) { 80c98 < atoi(value), 16777216); --- > atoi(value), DFLT_CB_BUFFER_SIZE); 84c102 < if (strcmp("automatic", value)) { --- > if (strcmp(DFLT_ROMIO_CB_READ, value)) { 87c105 < value, "automatic"); --- > value, DFLT_ROMIO_CB_READ); 91c109 < if (strcmp("automatic", value)) { --- > if (strcmp(DFLT_ROMIO_CB_WRITE, value)) { 94c112 < value, "automatic"); --- > value, DFLT_ROMIO_CB_WRITE); 115c133 < if (atoi(value) != 4194304) { --- > if (atoi(value) != DFLT_IND_RD_BUFFER_SIZE) { 118c136 < atoi(value), 4194304); --- > atoi(value), DFLT_IND_RD_BUFFER_SIZE); 122c140 < if (atoi(value) != 524288) { --- > if (atoi(value) != DFLT_IND_WR_BUFFER_SIZE) { 125c143 < atoi(value), 524288); --- > atoi(value), DFLT_IND_WR_BUFFER_SIZE); 145a164 > #if !ON_BGL 150a170 > #endif 203a224 > #if !ON_BGL 205a227 > #endif 253c275 < if (strcmp("automatic", value)) { --- > if (strcmp(DFLT_ROMIO_CB_READ, value)) { 256c278 < value, "automatic"); --- > value, DFLT_ROMIO_CB_READ); 260c282 < if (strcmp("automatic", value)) { --- > if (strcmp(DFLT_ROMIO_CB_WRITE, value)) { 263c285 < value, "automatic"); --- > value, DFLT_ROMIO_CB_WRITE); 311a334,335 > /* Unreliable test -- value is file system dependent. Ignore. */ > #if !ON_BGL 316a341 > #endif diff -rN mpich2-1.0.7rc1/src/mpi/timer/mpidtime.c bgp-mpich2/src/mpi/timer/mpidtime.c 98a99,112 > > #elif MPICH_TIMER_KIND == USE_DEVICE > > /* > * This is simply a generic holder that allows the device to define > * the results--and we don't have to litter the MPICH2 distributed > * code. Configure will set "typedef double MPID_Time_t" for this > * interface. > * > * The true implementation should be in > * mpich2/src/mpid/__DEVICE__/..../mpid_time.c > * mpich2/src/mpid/dcmf/src/misc/mpid_time.c > */ > diff -rN mpich2-1.0.7rc1/src/mpid/common/datatype/gen_type_blockindexed.c bgp-mpich2/src/mpid/common/datatype/gen_type_blockindexed.c 0a1,275 > /* -*- Mode: C; c-basic-offset:4 ; -*- */ > > /* > * (C) 2001 by Argonne National Laboratory. > * See COPYRIGHT in top-level directory. > */ > > #include > #include > > int MPIDI_Type_blockindexed_count_contig(int count, > int blklen, > void *disp_array, > int dispinbytes, > MPI_Aint old_extent); > > static void DLOOP_Type_blockindexed_array_copy(int count, > void *disp_array, > MPI_Aint *out_disp_array, > int dispinbytes, > MPI_Aint old_extent); > > /*@ > Dataloop_create_blockindexed - create blockindexed dataloop > > Arguments: > + int count > . void *displacement_array > . int displacement_in_bytes (boolean) > . MPI_Datatype old_type > . MPID_Dataloop **output_dataloop_ptr > . int output_dataloop_size > . int output_dataloop_depth > - int flags > > .N Errors > .N Returns 0 on success, -1 on failure. > @*/ > int PREPEND_PREFIX(Dataloop_create_blockindexed)(int count, > int blklen, > void *disp_array, > int dispinbytes, > DLOOP_Type oldtype, > DLOOP_Dataloop **dlp_p, > int *dlsz_p, > int *dldepth_p, > int flags) > { > int err, is_builtin, is_vectorizable = 1; > int i, new_loop_sz, old_loop_depth; > int contig_count; > > DLOOP_Offset old_extent, eff_disp0, eff_disp1, last_stride; > > DLOOP_Dataloop *new_dlp; > > /* if count or blklen are zero, handle with contig code, call it a int */ > if (count == 0 || blklen == 0) > { > err = PREPEND_PREFIX(Dataloop_create_contiguous)(0, > MPI_INT, > dlp_p, > dlsz_p, > dldepth_p, > flags); > return err; > } > > is_builtin = (DLOOP_Handle_hasloop_macro(oldtype)) ? 0 : 1; > > if (is_builtin) > { > old_extent = MPID_Datatype_get_basic_size(oldtype); > old_loop_depth = 0; > } > else > { > DLOOP_Handle_get_extent_macro(oldtype, old_extent); > DLOOP_Handle_get_loopdepth_macro(oldtype, old_loop_depth, 0); > } > > /* TODO: WHAT DO WE DO ABOUT THIS? */ > contig_count = MPIDI_Type_blockindexed_count_contig(count, > blklen, > disp_array, > dispinbytes, > old_extent); > > /* optimization: > * > * if contig_count == 1 and block starts at displacement 0, > * store it as a contiguous rather than a blockindexed dataloop. > */ > if ((contig_count == 1) && > ((!dispinbytes && ((int *) disp_array)[0] == 0) || > (dispinbytes && ((DLOOP_Offset *) disp_array)[0] == 0))) > { > err = PREPEND_PREFIX(Dataloop_create_contiguous)(count * blklen, > oldtype, > dlp_p, > dlsz_p, > dldepth_p, > flags); > return err; > } > > /* optimization: > * > * if contig_count == 1 store it as a blockindexed with one > * element rather than as a lot of individual blocks. > */ > if (contig_count == 1) > { > /* adjust count and blklen and drop through */ > blklen *= count; > count = 1; > } > > /* optimization: > * > * if displacements start at zero and result in a fixed stride, > * store it as a vector rather than a blockindexed dataloop. > */ > eff_disp0 = (dispinbytes) ? ((DLOOP_Offset *) disp_array)[0] : > (((MPI_Aint) ((int *) disp_array)[0]) * old_extent); > > if (count > 1 && eff_disp0 == (DLOOP_Offset) 0) > { > eff_disp1 = (dispinbytes) ? ((DLOOP_Offset *) disp_array)[1] : > (((DLOOP_Offset) ((int *) disp_array)[1]) * old_extent); > last_stride = eff_disp1 - eff_disp0; > > for (i=2; i < count; i++) { > eff_disp0 = eff_disp1; > eff_disp1 = (dispinbytes) ? ((DLOOP_Offset *) disp_array)[i] : > (((DLOOP_Offset) ((int *) disp_array)[i]) * old_extent); > if (eff_disp1 - eff_disp0 != last_stride) { > is_vectorizable = 0; > break; > } > } > if (is_vectorizable) > { > err = PREPEND_PREFIX(Dataloop_create_vector)(count, > blklen, > last_stride, > 1, /* strideinbytes */ > oldtype, > dlp_p, > dlsz_p, > dldepth_p, > flags); > return err; > } > } > > /* TODO: optimization: > * > * if displacements result in a fixed stride, but first displacement > * is not zero, store it as a blockindexed (blklen == 1) of a vector. > */ > > /* TODO: optimization: > * > * if a blockindexed of a contig, absorb the contig into the blocklen > * parameter and keep the same overall depth > */ > > /* otherwise storing as a blockindexed dataloop */ > > /* Q: HOW CAN WE TELL IF IT IS WORTH IT TO STORE AS AN > * INDEXED WITH FEWER CONTIG BLOCKS (IF CONTIG_COUNT IS SMALL)? > */ > > if (is_builtin) > { > PREPEND_PREFIX(Dataloop_alloc)(DLOOP_KIND_BLOCKINDEXED, > count, > &new_dlp, > &new_loop_sz); > /* --BEGIN ERROR HANDLING-- */ > if (!new_dlp) return -1; > /* --END ERROR HANDLING-- */ > > new_dlp->kind = DLOOP_KIND_BLOCKINDEXED | DLOOP_FINAL_MASK; > > /* TODO: MPID FLAGS? */ > if (flags & MPID_DATALOOP_ALL_BYTES) > { > blklen *= old_extent; > new_dlp->el_size = 1; > new_dlp->el_extent = 1; > new_dlp->el_type = MPI_BYTE; > } > else > { > new_dlp->el_size = old_extent; > new_dlp->el_extent = old_extent; > new_dlp->el_type = oldtype; > } > } > else > { > DLOOP_Dataloop *old_loop_ptr = NULL; > int old_loop_sz = 0; > > DLOOP_Handle_get_loopptr_macro(oldtype, old_loop_ptr, 0); > DLOOP_Handle_get_loopsize_macro(oldtype, old_loop_sz, 0); > > PREPEND_PREFIX(Dataloop_alloc_and_copy)(DLOOP_KIND_BLOCKINDEXED, > count, > old_loop_ptr, > old_loop_sz, > &new_dlp, > &new_loop_sz); > /* --BEGIN ERROR HANDLING-- */ > if (!new_dlp) return -1; > /* --END ERROR HANDLING-- */ > > new_dlp->kind = DLOOP_KIND_BLOCKINDEXED; > > DLOOP_Handle_get_size_macro(oldtype, new_dlp->el_size); > DLOOP_Handle_get_extent_macro(oldtype, new_dlp->el_extent); > DLOOP_Handle_get_basic_type_macro(oldtype, new_dlp->el_type); > } > > new_dlp->loop_params.bi_t.count = count; > new_dlp->loop_params.bi_t.blocksize = blklen; > > /* copy in displacement parameters > * > * regardless of dispinbytes, we store displacements in bytes in loop. > */ > DLOOP_Type_blockindexed_array_copy(count, > disp_array, > new_dlp->loop_params.bi_t.offset_array, > dispinbytes, > old_extent); > > *dlp_p = new_dlp; > *dlsz_p = new_loop_sz; > *dldepth_p = old_loop_depth + 1; > > return 0; > } > > /* DLOOP_Type_blockindexed_array_copy > * > * Unlike the indexed version, this one does not compact adjacent > * blocks, because that would really mess up the blockindexed type! > */ > static void DLOOP_Type_blockindexed_array_copy(int count, > void *in_disp_array, > DLOOP_Offset *out_disp_array, > int dispinbytes, > DLOOP_Offset old_extent) > { > int i; > if (!dispinbytes) > { > for (i=0; i < count; i++) > { > out_disp_array[i] = > ((DLOOP_Offset) ((int *) in_disp_array)[i]) * old_extent; > } > } > else > { > for (i=0; i < count; i++) > { > out_disp_array[i] = ((DLOOP_Offset *) in_disp_array)[i]; > } > } > return; > } diff -rN mpich2-1.0.7rc1/src/mpid/common/datatype/mpid_type_create_pairtype.c bgp-mpich2/src/mpid/common/datatype/mpid_type_create_pairtype.c 160c160 < #else --- > #elif defined(HAVE_MAX_FP_ALIGNMENT) diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/configure bgp-mpich2/src/mpid/dcmf/configure 0a1,3112 > #! /bin/sh > # Guess values for system-dependent variables and create Makefiles. > # Generated by GNU Autoconf 2.59. > # > # Copyright (C) 2003 Free Software Foundation, Inc. > # This configure script is free software; the Free Software Foundation > # gives unlimited permission to copy, distribute and modify it. > ## --------------------- ## > ## M4sh Initialization. ## > ## --------------------- ## > > # Be Bourne compatible > if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then > emulate sh > NULLCMD=: > # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which > # is contrary to our usage. Disable this feature. > alias -g '${1+"$@"}'='"$@"' > elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then > set -o posix > fi > DUALCASE=1; export DUALCASE # for MKS sh > > # Support unset when possible. > if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then > as_unset=unset > else > as_unset=false > fi > > > # Work around bugs in pre-3.0 UWIN ksh. > $as_unset ENV MAIL MAILPATH > PS1='$ ' > PS2='> ' > PS4='+ ' > > # NLS nuisances. > for as_var in \ > LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \ > LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \ > LC_TELEPHONE LC_TIME > do > if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then > eval $as_var=C; export $as_var > else > $as_unset $as_var > fi > done > > # Required to use basename. > if expr a : '\(a\)' >/dev/null 2>&1; then > as_expr=expr > else > as_expr=false > fi > > if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then > as_basename=basename > else > as_basename=false > fi > > > # Name of the executable. > as_me=`$as_basename "$0" || > $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \ > X"$0" : 'X\(//\)$' \| \ > X"$0" : 'X\(/\)$' \| \ > . : '\(.\)' 2>/dev/null || > echo X/"$0" | > sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; } > /^X\/\(\/\/\)$/{ s//\1/; q; } > /^X\/\(\/\).*/{ s//\1/; q; } > s/.*/./; q'` > > > # PATH needs CR, and LINENO needs CR and PATH. > # Avoid depending upon Character Ranges. > as_cr_letters='abcdefghijklmnopqrstuvwxyz' > as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ' > as_cr_Letters=$as_cr_letters$as_cr_LETTERS > as_cr_digits='0123456789' > as_cr_alnum=$as_cr_Letters$as_cr_digits > > # The user is always right. > if test "${PATH_SEPARATOR+set}" != set; then > echo "#! /bin/sh" >conf$$.sh > echo "exit 0" >>conf$$.sh > chmod +x conf$$.sh > if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then > PATH_SEPARATOR=';' > else > PATH_SEPARATOR=: > fi > rm -f conf$$.sh > fi > > > as_lineno_1=$LINENO > as_lineno_2=$LINENO > as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null` > test "x$as_lineno_1" != "x$as_lineno_2" && > test "x$as_lineno_3" = "x$as_lineno_2" || { > # Find who we are. Look in the path if we contain no path at all > # relative or not. > case $0 in > *[\\/]* ) as_myself=$0 ;; > *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR > for as_dir in $PATH > do > IFS=$as_save_IFS > test -z "$as_dir" && as_dir=. > test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break > done > > ;; > esac > # We did not find ourselves, most probably we were run as `sh COMMAND' > # in which case we are not to be found in the path. > if test "x$as_myself" = x; then > as_myself=$0 > fi > if test ! -f "$as_myself"; then > { echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2 > { (exit 1); exit 1; }; } > fi > case $CONFIG_SHELL in > '') > as_save_IFS=$IFS; IFS=$PATH_SEPARATOR > for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH > do > IFS=$as_save_IFS > test -z "$as_dir" && as_dir=. > for as_base in sh bash ksh sh5; do > case $as_dir in > /*) > if ("$as_dir/$as_base" -c ' > as_lineno_1=$LINENO > as_lineno_2=$LINENO > as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null` > test "x$as_lineno_1" != "x$as_lineno_2" && > test "x$as_lineno_3" = "x$as_lineno_2" ') 2>/dev/null; then > $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; } > $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; } > CONFIG_SHELL=$as_dir/$as_base > export CONFIG_SHELL > exec "$CONFIG_SHELL" "$0" ${1+"$@"} > fi;; > esac > done > done > ;; > esac > > # Create $as_me.lineno as a copy of $as_myself, but with $LINENO > # uniformly replaced by the line number. The first 'sed' inserts a > # line-number line before each line; the second 'sed' does the real > # work. The second script uses 'N' to pair each line-number line > # with the numbered line, and appends trailing '-' during > # substitution so that $LINENO is not a special case at line end. > # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the > # second 'sed' script. Blame Lee E. McMahon for sed's syntax. :-) > sed '=' <$as_myself | > sed ' > N > s,$,-, > : loop > s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3, > t loop > s,-$,, > s,^['$as_cr_digits']*\n,, > ' >$as_me.lineno && > chmod +x $as_me.lineno || > { echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2 > { (exit 1); exit 1; }; } > > # Don't try to exec as it changes $[0], causing all sort of problems > # (the dirname of $[0] is not the place where we might find the > # original and so on. Autoconf is especially sensible to this). > . ./$as_me.lineno > # Exit status is that of the last command. > exit > } > > > case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in > *c*,-n*) ECHO_N= ECHO_C=' > ' ECHO_T=' ' ;; > *c*,* ) ECHO_N=-n ECHO_C= ECHO_T= ;; > *) ECHO_N= ECHO_C='\c' ECHO_T= ;; > esac > > if expr a : '\(a\)' >/dev/null 2>&1; then > as_expr=expr > else > as_expr=false > fi > > rm -f conf$$ conf$$.exe conf$$.file > echo >conf$$.file > if ln -s conf$$.file conf$$ 2>/dev/null; then > # We could just check for DJGPP; but this test a) works b) is more generic > # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04). > if test -f conf$$.exe; then > # Don't use ln at all; we don't have any links > as_ln_s='cp -p' > else > as_ln_s='ln -s' > fi > elif ln conf$$.file conf$$ 2>/dev/null; then > as_ln_s=ln > else > as_ln_s='cp -p' > fi > rm -f conf$$ conf$$.exe conf$$.file > > if mkdir -p . 2>/dev/null; then > as_mkdir_p=: > else > test -d ./-p && rmdir ./-p > as_mkdir_p=false > fi > > as_executable_p="test -f" > > # Sed expression to map a string onto a valid CPP name. > as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'" > > # Sed expression to map a string onto a valid variable name. > as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'" > > > # IFS > # We need space, tab and new line, in precisely that order. > as_nl=' > ' > IFS=" $as_nl" > > # CDPATH. > $as_unset CDPATH > > > # Name of the host. > # hostname on some systems (SVR3.2, Linux) returns a bogus exit status, > # so uname gets run too. > ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q` > > exec 6>&1 > > # > # Initializations. > # > ac_default_prefix=/usr/local > ac_config_libobj_dir=. > cross_compiling=no > subdirs= > MFLAGS= > MAKEFLAGS= > SHELL=${CONFIG_SHELL-/bin/sh} > > # Maximum number of lines to put in a shell here document. > # This variable seems obsolete. It should probably be removed, and > # only ac_max_sed_lines should be used. > : ${ac_max_here_lines=38} > > # Identity of this package. > PACKAGE_NAME= > PACKAGE_TARNAME= > PACKAGE_VERSION= > PACKAGE_STRING= > PACKAGE_BUGREPORT= > > ac_unique_file="configure.in" > ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS MAKE VPATH SET_CFLAGS SET_MAKE ASSERT_LEVEL MPID_THREAD_SOURCES MPID_THREAD_DISTCLEAN AR RANLIB MPILIBNAME CC CFLAGS CPPFLAGS CC_SHL C_LINK_SHL master_top_srcdir master_top_builddir MAKE_DEPEND_C ENABLE_SHLIB MKDIR_P INSTALL INSTALL_DATA INSTALL_PROGRAM LIBOBJS LTLIBOBJS' > ac_subst_files='MPID_THREAD_TYPEDEFS MPID_THREAD_FUNCS' > > # Initialize some variables set by options. > ac_init_help= > ac_init_version=false > # The variables have the same names as the options, with > # dashes changed to underlines. > cache_file=/dev/null > exec_prefix=NONE > no_create= > no_recursion= > prefix=NONE > program_prefix=NONE > program_suffix=NONE > program_transform_name=s,x,x, > silent= > site= > srcdir= > verbose= > x_includes=NONE > x_libraries=NONE > > # Installation directory options. > # These are left unexpanded so users can "make install exec_prefix=/foo" > # and all the variables that are supposed to be based on exec_prefix > # by default will actually change. > # Use braces instead of parens because sh, perl, etc. also accept them. > bindir='${exec_prefix}/bin' > sbindir='${exec_prefix}/sbin' > libexecdir='${exec_prefix}/libexec' > datadir='${prefix}/share' > sysconfdir='${prefix}/etc' > sharedstatedir='${prefix}/com' > localstatedir='${prefix}/var' > libdir='${exec_prefix}/lib' > includedir='${prefix}/include' > oldincludedir='/usr/include' > infodir='${prefix}/info' > mandir='${prefix}/man' > > ac_prev= > for ac_option > do > # If the previous option needs an argument, assign it. > if test -n "$ac_prev"; then > eval "$ac_prev=\$ac_option" > ac_prev= > continue > fi > > ac_optarg=`expr "x$ac_option" : 'x[^=]*=\(.*\)'` > > # Accept the important Cygnus configure options, so we can diagnose typos. > > case $ac_option in > > -bindir | --bindir | --bindi | --bind | --bin | --bi) > ac_prev=bindir ;; > -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*) > bindir=$ac_optarg ;; > > -build | --build | --buil | --bui | --bu) > ac_prev=build_alias ;; > -build=* | --build=* | --buil=* | --bui=* | --bu=*) > build_alias=$ac_optarg ;; > > -cache-file | --cache-file | --cache-fil | --cache-fi \ > | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c) > ac_prev=cache_file ;; > -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \ > | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*) > cache_file=$ac_optarg ;; > > --config-cache | -C) > cache_file=config.cache ;; > > -datadir | --datadir | --datadi | --datad | --data | --dat | --da) > ac_prev=datadir ;; > -datadir=* | --datadir=* | --datadi=* | --datad=* | --data=* | --dat=* \ > | --da=*) > datadir=$ac_optarg ;; > > -disable-* | --disable-*) > ac_feature=`expr "x$ac_option" : 'x-*disable-\(.*\)'` > # Reject names that are not valid shell variable names. > expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null && > { echo "$as_me: error: invalid feature name: $ac_feature" >&2 > { (exit 1); exit 1; }; } > ac_feature=`echo $ac_feature | sed 's/-/_/g'` > eval "enable_$ac_feature=no" ;; > > -enable-* | --enable-*) > ac_feature=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'` > # Reject names that are not valid shell variable names. > expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null && > { echo "$as_me: error: invalid feature name: $ac_feature" >&2 > { (exit 1); exit 1; }; } > ac_feature=`echo $ac_feature | sed 's/-/_/g'` > case $ac_option in > *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;; > *) ac_optarg=yes ;; > esac > eval "enable_$ac_feature='$ac_optarg'" ;; > > -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \ > | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \ > | --exec | --exe | --ex) > ac_prev=exec_prefix ;; > -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \ > | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \ > | --exec=* | --exe=* | --ex=*) > exec_prefix=$ac_optarg ;; > > -gas | --gas | --ga | --g) > # Obsolete; use --with-gas. > with_gas=yes ;; > > -help | --help | --hel | --he | -h) > ac_init_help=long ;; > -help=r* | --help=r* | --hel=r* | --he=r* | -hr*) > ac_init_help=recursive ;; > -help=s* | --help=s* | --hel=s* | --he=s* | -hs*) > ac_init_help=short ;; > > -host | --host | --hos | --ho) > ac_prev=host_alias ;; > -host=* | --host=* | --hos=* | --ho=*) > host_alias=$ac_optarg ;; > > -includedir | --includedir | --includedi | --included | --include \ > | --includ | --inclu | --incl | --inc) > ac_prev=includedir ;; > -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \ > | --includ=* | --inclu=* | --incl=* | --inc=*) > includedir=$ac_optarg ;; > > -infodir | --infodir | --infodi | --infod | --info | --inf) > ac_prev=infodir ;; > -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*) > infodir=$ac_optarg ;; > > -libdir | --libdir | --libdi | --libd) > ac_prev=libdir ;; > -libdir=* | --libdir=* | --libdi=* | --libd=*) > libdir=$ac_optarg ;; > > -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \ > | --libexe | --libex | --libe) > ac_prev=libexecdir ;; > -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \ > | --libexe=* | --libex=* | --libe=*) > libexecdir=$ac_optarg ;; > > -localstatedir | --localstatedir | --localstatedi | --localstated \ > | --localstate | --localstat | --localsta | --localst \ > | --locals | --local | --loca | --loc | --lo) > ac_prev=localstatedir ;; > -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \ > | --localstate=* | --localstat=* | --localsta=* | --localst=* \ > | --locals=* | --local=* | --loca=* | --loc=* | --lo=*) > localstatedir=$ac_optarg ;; > > -mandir | --mandir | --mandi | --mand | --man | --ma | --m) > ac_prev=mandir ;; > -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*) > mandir=$ac_optarg ;; > > -nfp | --nfp | --nf) > # Obsolete; use --without-fp. > with_fp=no ;; > > -no-create | --no-create | --no-creat | --no-crea | --no-cre \ > | --no-cr | --no-c | -n) > no_create=yes ;; > > -no-recursion | --no-recursion | --no-recursio | --no-recursi \ > | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r) > no_recursion=yes ;; > > -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \ > | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \ > | --oldin | --oldi | --old | --ol | --o) > ac_prev=oldincludedir ;; > -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \ > | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \ > | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*) > oldincludedir=$ac_optarg ;; > > -prefix | --prefix | --prefi | --pref | --pre | --pr | --p) > ac_prev=prefix ;; > -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*) > prefix=$ac_optarg ;; > > -program-prefix | --program-prefix | --program-prefi | --program-pref \ > | --program-pre | --program-pr | --program-p) > ac_prev=program_prefix ;; > -program-prefix=* | --program-prefix=* | --program-prefi=* \ > | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*) > program_prefix=$ac_optarg ;; > > -program-suffix | --program-suffix | --program-suffi | --program-suff \ > | --program-suf | --program-su | --program-s) > ac_prev=program_suffix ;; > -program-suffix=* | --program-suffix=* | --program-suffi=* \ > | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*) > program_suffix=$ac_optarg ;; > > -program-transform-name | --program-transform-name \ > | --program-transform-nam | --program-transform-na \ > | --program-transform-n | --program-transform- \ > | --program-transform | --program-transfor \ > | --program-transfo | --program-transf \ > | --program-trans | --program-tran \ > | --progr-tra | --program-tr | --program-t) > ac_prev=program_transform_name ;; > -program-transform-name=* | --program-transform-name=* \ > | --program-transform-nam=* | --program-transform-na=* \ > | --program-transform-n=* | --program-transform-=* \ > | --program-transform=* | --program-transfor=* \ > | --program-transfo=* | --program-transf=* \ > | --program-trans=* | --program-tran=* \ > | --progr-tra=* | --program-tr=* | --program-t=*) > program_transform_name=$ac_optarg ;; > > -q | -quiet | --quiet | --quie | --qui | --qu | --q \ > | -silent | --silent | --silen | --sile | --sil) > silent=yes ;; > > -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb) > ac_prev=sbindir ;; > -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \ > | --sbi=* | --sb=*) > sbindir=$ac_optarg ;; > > -sharedstatedir | --sharedstatedir | --sharedstatedi \ > | --sharedstated | --sharedstate | --sharedstat | --sharedsta \ > | --sharedst | --shareds | --shared | --share | --shar \ > | --sha | --sh) > ac_prev=sharedstatedir ;; > -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \ > | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \ > | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \ > | --sha=* | --sh=*) > sharedstatedir=$ac_optarg ;; > > -site | --site | --sit) > ac_prev=site ;; > -site=* | --site=* | --sit=*) > site=$ac_optarg ;; > > -srcdir | --srcdir | --srcdi | --srcd | --src | --sr) > ac_prev=srcdir ;; > -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*) > srcdir=$ac_optarg ;; > > -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \ > | --syscon | --sysco | --sysc | --sys | --sy) > ac_prev=sysconfdir ;; > -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \ > | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*) > sysconfdir=$ac_optarg ;; > > -target | --target | --targe | --targ | --tar | --ta | --t) > ac_prev=target_alias ;; > -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*) > target_alias=$ac_optarg ;; > > -v | -verbose | --verbose | --verbos | --verbo | --verb) > verbose=yes ;; > > -version | --version | --versio | --versi | --vers | -V) > ac_init_version=: ;; > > -with-* | --with-*) > ac_package=`expr "x$ac_option" : 'x-*with-\([^=]*\)'` > # Reject names that are not valid shell variable names. > expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null && > { echo "$as_me: error: invalid package name: $ac_package" >&2 > { (exit 1); exit 1; }; } > ac_package=`echo $ac_package| sed 's/-/_/g'` > case $ac_option in > *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;; > *) ac_optarg=yes ;; > esac > eval "with_$ac_package='$ac_optarg'" ;; > > -without-* | --without-*) > ac_package=`expr "x$ac_option" : 'x-*without-\(.*\)'` > # Reject names that are not valid shell variable names. > expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null && > { echo "$as_me: error: invalid package name: $ac_package" >&2 > { (exit 1); exit 1; }; } > ac_package=`echo $ac_package | sed 's/-/_/g'` > eval "with_$ac_package=no" ;; > > --x) > # Obsolete; use --with-x. > with_x=yes ;; > > -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \ > | --x-incl | --x-inc | --x-in | --x-i) > ac_prev=x_includes ;; > -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \ > | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*) > x_includes=$ac_optarg ;; > > -x-libraries | --x-libraries | --x-librarie | --x-librari \ > | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l) > ac_prev=x_libraries ;; > -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \ > | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*) > x_libraries=$ac_optarg ;; > > -*) { echo "$as_me: error: unrecognized option: $ac_option > Try \`$0 --help' for more information." >&2 > { (exit 1); exit 1; }; } > ;; > > *=*) > ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='` > # Reject names that are not valid shell variable names. > expr "x$ac_envvar" : ".*[^_$as_cr_alnum]" >/dev/null && > { echo "$as_me: error: invalid variable name: $ac_envvar" >&2 > { (exit 1); exit 1; }; } > ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` > eval "$ac_envvar='$ac_optarg'" > export $ac_envvar ;; > > *) > # FIXME: should be removed in autoconf 3.0. > echo "$as_me: WARNING: you should use --build, --host, --target" >&2 > expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null && > echo "$as_me: WARNING: invalid host type: $ac_option" >&2 > : ${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option} > ;; > > esac > done > > if test -n "$ac_prev"; then > ac_option=--`echo $ac_prev | sed 's/_/-/g'` > { echo "$as_me: error: missing argument to $ac_option" >&2 > { (exit 1); exit 1; }; } > fi > > # Be sure to have absolute paths. > for ac_var in exec_prefix prefix > do > eval ac_val=$`echo $ac_var` > case $ac_val in > [\\/$]* | ?:[\\/]* | NONE | '' ) ;; > *) { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2 > { (exit 1); exit 1; }; };; > esac > done > > # Be sure to have absolute paths. > for ac_var in bindir sbindir libexecdir datadir sysconfdir sharedstatedir \ > localstatedir libdir includedir oldincludedir infodir mandir > do > eval ac_val=$`echo $ac_var` > case $ac_val in > [\\/$]* | ?:[\\/]* ) ;; > *) { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2 > { (exit 1); exit 1; }; };; > esac > done > > # There might be people who depend on the old broken behavior: `$host' > # used to hold the argument of --host etc. > # FIXME: To remove some day. > build=$build_alias > host=$host_alias > target=$target_alias > > # FIXME: To remove some day. > if test "x$host_alias" != x; then > if test "x$build_alias" = x; then > cross_compiling=maybe > echo "$as_me: WARNING: If you wanted to set the --build type, don't use --host. > If a cross compiler is detected then cross compile mode will be used." >&2 > elif test "x$build_alias" != "x$host_alias"; then > cross_compiling=yes > fi > fi > > ac_tool_prefix= > test -n "$host_alias" && ac_tool_prefix=$host_alias- > > test "$silent" = yes && exec 6>/dev/null > > > # Find the source files, if location was not specified. > if test -z "$srcdir"; then > ac_srcdir_defaulted=yes > # Try the directory containing this script, then its parent. > ac_confdir=`(dirname "$0") 2>/dev/null || > $as_expr X"$0" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ > X"$0" : 'X\(//\)[^/]' \| \ > X"$0" : 'X\(//\)$' \| \ > X"$0" : 'X\(/\)' \| \ > . : '\(.\)' 2>/dev/null || > echo X"$0" | > sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; } > /^X\(\/\/\)[^/].*/{ s//\1/; q; } > /^X\(\/\/\)$/{ s//\1/; q; } > /^X\(\/\).*/{ s//\1/; q; } > s/.*/./; q'` > srcdir=$ac_confdir > if test ! -r $srcdir/$ac_unique_file; then > srcdir=.. > fi > else > ac_srcdir_defaulted=no > fi > if test ! -r $srcdir/$ac_unique_file; then > if test "$ac_srcdir_defaulted" = yes; then > { echo "$as_me: error: cannot find sources ($ac_unique_file) in $ac_confdir or .." >&2 > { (exit 1); exit 1; }; } > else > { echo "$as_me: error: cannot find sources ($ac_unique_file) in $srcdir" >&2 > { (exit 1); exit 1; }; } > fi > fi > (cd $srcdir && test -r ./$ac_unique_file) 2>/dev/null || > { echo "$as_me: error: sources are in $srcdir, but \`cd $srcdir' does not work" >&2 > { (exit 1); exit 1; }; } > srcdir=`echo "$srcdir" | sed 's%\([^\\/]\)[\\/]*$%\1%'` > ac_env_build_alias_set=${build_alias+set} > ac_env_build_alias_value=$build_alias > ac_cv_env_build_alias_set=${build_alias+set} > ac_cv_env_build_alias_value=$build_alias > ac_env_host_alias_set=${host_alias+set} > ac_env_host_alias_value=$host_alias > ac_cv_env_host_alias_set=${host_alias+set} > ac_cv_env_host_alias_value=$host_alias > ac_env_target_alias_set=${target_alias+set} > ac_env_target_alias_value=$target_alias > ac_cv_env_target_alias_set=${target_alias+set} > ac_cv_env_target_alias_value=$target_alias > > # > # Report the --help message. > # > if test "$ac_init_help" = "long"; then > # Omit some internal or obsolete options to make the list less imposing. > # This message is too long to be a string in the A/UX 3.1 sh. > cat <<_ACEOF > \`configure' configures this package to adapt to many kinds of systems. > > Usage: $0 [OPTION]... [VAR=VALUE]... > > To assign environment variables (e.g., CC, CFLAGS...), specify them as > VAR=VALUE. See below for descriptions of some of the useful variables. > > Defaults for the options are specified in brackets. > > Configuration: > -h, --help display this help and exit > --help=short display options specific to this package > --help=recursive display the short help of all the included packages > -V, --version display version information and exit > -q, --quiet, --silent do not print \`checking...' messages > --cache-file=FILE cache test results in FILE [disabled] > -C, --config-cache alias for \`--cache-file=config.cache' > -n, --no-create do not create output files > --srcdir=DIR find the sources in DIR [configure dir or \`..'] > > _ACEOF > > cat <<_ACEOF > Installation directories: > --prefix=PREFIX install architecture-independent files in PREFIX > [$ac_default_prefix] > --exec-prefix=EPREFIX install architecture-dependent files in EPREFIX > [PREFIX] > > By default, \`make install' will install all the files in > \`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc. You can specify > an installation prefix other than \`$ac_default_prefix' using \`--prefix', > for instance \`--prefix=\$HOME'. > > For better control, use the options below. > > Fine tuning of the installation directories: > --bindir=DIR user executables [EPREFIX/bin] > --sbindir=DIR system admin executables [EPREFIX/sbin] > --libexecdir=DIR program executables [EPREFIX/libexec] > --datadir=DIR read-only architecture-independent data [PREFIX/share] > --sysconfdir=DIR read-only single-machine data [PREFIX/etc] > --sharedstatedir=DIR modifiable architecture-independent data [PREFIX/com] > --localstatedir=DIR modifiable single-machine data [PREFIX/var] > --libdir=DIR object code libraries [EPREFIX/lib] > --includedir=DIR C header files [PREFIX/include] > --oldincludedir=DIR C header files for non-gcc [/usr/include] > --infodir=DIR info documentation [PREFIX/info] > --mandir=DIR man documentation [PREFIX/man] > _ACEOF > > cat <<\_ACEOF > _ACEOF > fi > > if test -n "$ac_init_help"; then > > cat <<\_ACEOF > > Optional Features: > --disable-FEATURE do not include FEATURE (same as --enable-FEATURE=no) > --enable-FEATURE[=ARG] include FEATURE [ARG=yes] > --enable-cache - Turn on configure caching > > Optional Packages: > --with-PACKAGE[=ARG] use PACKAGE [ARG=yes] > --without-PACKAGE do not use PACKAGE (same as --with-PACKAGE=no) > --with-assert-level={0 1 2} > set build assert-level (default: 2) > > _ACEOF > fi > > if test "$ac_init_help" = "recursive"; then > # If there are subdirs, report their specific --help. > ac_popdir=`pwd` > for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue > test -d $ac_dir || continue > ac_builddir=. > > if test "$ac_dir" != .; then > ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'` > # A "../" for each directory in $ac_dir_suffix. > ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'` > else > ac_dir_suffix= ac_top_builddir= > fi > > case $srcdir in > .) # No --srcdir option. We are building in place. > ac_srcdir=. > if test -z "$ac_top_builddir"; then > ac_top_srcdir=. > else > ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'` > fi ;; > [\\/]* | ?:[\\/]* ) # Absolute path. > ac_srcdir=$srcdir$ac_dir_suffix; > ac_top_srcdir=$srcdir ;; > *) # Relative path. > ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix > ac_top_srcdir=$ac_top_builddir$srcdir ;; > esac > > # Do not use `cd foo && pwd` to compute absolute paths, because > # the directories may not exist. > case `pwd` in > .) ac_abs_builddir="$ac_dir";; > *) > case "$ac_dir" in > .) ac_abs_builddir=`pwd`;; > [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";; > *) ac_abs_builddir=`pwd`/"$ac_dir";; > esac;; > esac > case $ac_abs_builddir in > .) ac_abs_top_builddir=${ac_top_builddir}.;; > *) > case ${ac_top_builddir}. in > .) ac_abs_top_builddir=$ac_abs_builddir;; > [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;; > *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;; > esac;; > esac > case $ac_abs_builddir in > .) ac_abs_srcdir=$ac_srcdir;; > *) > case $ac_srcdir in > .) ac_abs_srcdir=$ac_abs_builddir;; > [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;; > *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;; > esac;; > esac > case $ac_abs_builddir in > .) ac_abs_top_srcdir=$ac_top_srcdir;; > *) > case $ac_top_srcdir in > .) ac_abs_top_srcdir=$ac_abs_builddir;; > [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;; > *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;; > esac;; > esac > > cd $ac_dir > # Check for guested configure; otherwise get Cygnus style configure. > if test -f $ac_srcdir/configure.gnu; then > echo > $SHELL $ac_srcdir/configure.gnu --help=recursive > elif test -f $ac_srcdir/configure; then > echo > $SHELL $ac_srcdir/configure --help=recursive > elif test -f $ac_srcdir/configure.ac || > test -f $ac_srcdir/configure.in; then > echo > $ac_configure --help > else > echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2 > fi > cd $ac_popdir > done > fi > > test -n "$ac_init_help" && exit 0 > if $ac_init_version; then > cat <<\_ACEOF > > Copyright (C) 2003 Free Software Foundation, Inc. > This configure script is free software; the Free Software Foundation > gives unlimited permission to copy, distribute and modify it. > _ACEOF > exit 0 > fi > exec 5>config.log > cat >&5 <<_ACEOF > This file contains any messages produced by compilers while > running configure, to aid debugging if configure makes a mistake. > > It was created by $as_me, which was > generated by GNU Autoconf 2.59. Invocation command line was > > $ $0 $@ > > _ACEOF > { > cat <<_ASUNAME > ## --------- ## > ## Platform. ## > ## --------- ## > > hostname = `(hostname || uname -n) 2>/dev/null | sed 1q` > uname -m = `(uname -m) 2>/dev/null || echo unknown` > uname -r = `(uname -r) 2>/dev/null || echo unknown` > uname -s = `(uname -s) 2>/dev/null || echo unknown` > uname -v = `(uname -v) 2>/dev/null || echo unknown` > > /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown` > /bin/uname -X = `(/bin/uname -X) 2>/dev/null || echo unknown` > > /bin/arch = `(/bin/arch) 2>/dev/null || echo unknown` > /usr/bin/arch -k = `(/usr/bin/arch -k) 2>/dev/null || echo unknown` > /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown` > hostinfo = `(hostinfo) 2>/dev/null || echo unknown` > /bin/machine = `(/bin/machine) 2>/dev/null || echo unknown` > /usr/bin/oslevel = `(/usr/bin/oslevel) 2>/dev/null || echo unknown` > /bin/universe = `(/bin/universe) 2>/dev/null || echo unknown` > > _ASUNAME > > as_save_IFS=$IFS; IFS=$PATH_SEPARATOR > for as_dir in $PATH > do > IFS=$as_save_IFS > test -z "$as_dir" && as_dir=. > echo "PATH: $as_dir" > done > > } >&5 > > cat >&5 <<_ACEOF > > > ## ----------- ## > ## Core tests. ## > ## ----------- ## > > _ACEOF > > > # Keep a trace of the command line. > # Strip out --no-create and --no-recursion so they do not pile up. > # Strip out --silent because we don't want to record it for future runs. > # Also quote any args containing shell meta-characters. > # Make two passes to allow for proper duplicate-argument suppression. > ac_configure_args= > ac_configure_args0= > ac_configure_args1= > ac_sep= > ac_must_keep_next=false > for ac_pass in 1 2 > do > for ac_arg > do > case $ac_arg in > -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;; > -q | -quiet | --quiet | --quie | --qui | --qu | --q \ > | -silent | --silent | --silen | --sile | --sil) > continue ;; > *" "*|*" "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*) > ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;; > esac > case $ac_pass in > 1) ac_configure_args0="$ac_configure_args0 '$ac_arg'" ;; > 2) > ac_configure_args1="$ac_configure_args1 '$ac_arg'" > if test $ac_must_keep_next = true; then > ac_must_keep_next=false # Got value, back to normal. > else > case $ac_arg in > *=* | --config-cache | -C | -disable-* | --disable-* \ > | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \ > | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \ > | -with-* | --with-* | -without-* | --without-* | --x) > case "$ac_configure_args0 " in > "$ac_configure_args1"*" '$ac_arg' "* ) continue ;; > esac > ;; > -* ) ac_must_keep_next=true ;; > esac > fi > ac_configure_args="$ac_configure_args$ac_sep'$ac_arg'" > # Get rid of the leading space. > ac_sep=" " > ;; > esac > done > done > $as_unset ac_configure_args0 || test "${ac_configure_args0+set}" != set || { ac_configure_args0=; export ac_configure_args0; } > $as_unset ac_configure_args1 || test "${ac_configure_args1+set}" != set || { ac_configure_args1=; export ac_configure_args1; } > > # When interrupted or exit'd, cleanup temporary files, and complete > # config.log. We remove comments because anyway the quotes in there > # would cause problems or look ugly. > # WARNING: Be sure not to use single quotes in there, as some shells, > # such as our DU 5.0 friend, will then `close' the trap. > trap 'exit_status=$? > # Save into config.log some information that might help in debugging. > { > echo > > cat <<\_ASBOX > ## ---------------- ## > ## Cache variables. ## > ## ---------------- ## > _ASBOX > echo > # The following way of writing the cache mishandles newlines in values, > { > (set) 2>&1 | > case `(ac_space='"'"' '"'"'; set | grep ac_space) 2>&1` in > *ac_space=\ *) > sed -n \ > "s/'"'"'/'"'"'\\\\'"'"''"'"'/g; > s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='"'"'\\2'"'"'/p" > ;; > *) > sed -n \ > "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p" > ;; > esac; > } > echo > > cat <<\_ASBOX > ## ----------------- ## > ## Output variables. ## > ## ----------------- ## > _ASBOX > echo > for ac_var in $ac_subst_vars > do > eval ac_val=$`echo $ac_var` > echo "$ac_var='"'"'$ac_val'"'"'" > done | sort > echo > > if test -n "$ac_subst_files"; then > cat <<\_ASBOX > ## ------------- ## > ## Output files. ## > ## ------------- ## > _ASBOX > echo > for ac_var in $ac_subst_files > do > eval ac_val=$`echo $ac_var` > echo "$ac_var='"'"'$ac_val'"'"'" > done | sort > echo > fi > > if test -s confdefs.h; then > cat <<\_ASBOX > ## ----------- ## > ## confdefs.h. ## > ## ----------- ## > _ASBOX > echo > sed "/^$/d" confdefs.h | sort > echo > fi > test "$ac_signal" != 0 && > echo "$as_me: caught signal $ac_signal" > echo "$as_me: exit $exit_status" > } >&5 > rm -f core *.core && > rm -rf conftest* confdefs* conf$$* $ac_clean_files && > exit $exit_status > ' 0 > for ac_signal in 1 2 13 15; do > trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' $ac_signal > done > ac_signal=0 > > # confdefs.h avoids OS command line length limits that DEFS can exceed. > rm -rf conftest* confdefs.h > # AIX cpp loses on an empty file, so make sure it contains at least a newline. > echo >confdefs.h > > # Predefined preprocessor variables. > > cat >>confdefs.h <<_ACEOF > #define PACKAGE_NAME "$PACKAGE_NAME" > _ACEOF > > > cat >>confdefs.h <<_ACEOF > #define PACKAGE_TARNAME "$PACKAGE_TARNAME" > _ACEOF > > > cat >>confdefs.h <<_ACEOF > #define PACKAGE_VERSION "$PACKAGE_VERSION" > _ACEOF > > > cat >>confdefs.h <<_ACEOF > #define PACKAGE_STRING "$PACKAGE_STRING" > _ACEOF > > > cat >>confdefs.h <<_ACEOF > #define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT" > _ACEOF > > > # Let the site file select an alternate cache file if it wants to. > # Prefer explicitly selected file to automatically selected ones. > if test -z "$CONFIG_SITE"; then > if test "x$prefix" != xNONE; then > CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site" > else > CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site" > fi > fi > for ac_site_file in $CONFIG_SITE; do > if test -r "$ac_site_file"; then > { echo "$as_me:$LINENO: loading site script $ac_site_file" >&5 > echo "$as_me: loading site script $ac_site_file" >&6;} > sed 's/^/| /' "$ac_site_file" >&5 > . "$ac_site_file" > fi > done > > if test "$CONFIGURE_DEBUG_CACHE" = yes ; then > oldopts="$-" > clearMinusX=no > set -x > if test "$oldopts" != "$-" ; then > clearMinusX=yes > fi > fi > if test "X$cache_system" = "X" ; then > # A default file name, just in case > cache_system="config.system" > if test "$cache_file" != "/dev/null" ; then > # Get the directory for the cache file, if any > > cache_system=`echo $cache_file | sed -e 's%^\(.*/\)[^/]*%\1config.system%'` > > test "x$cache_system" = "x$cache_file" && cache_system="config.system" > # else > # We must *not* set enable_cache to no because we need to know if > # enable_cache was not set. > # enable_cache=no > fi > fi > # > # Get a test value and flag whether we should remove/replace the > # cache_system file (do so unless cache_system_ok is yes) > # FC and F77 should be synonyms. Save both in case > # We include the xxxFLAGS in case the user is using the flags to change > # the language (either input or output) of the compiler. E.g., > # using -xarch=v9 on Solaris to select 64 bit output or using -D_BSD_SOURCE > # with gcc to get different header files on input. > cleanargs=`echo "$CC $F77 $FC $CXX $F90 $CFLAGS $FFLAGS $CXXFLAGS $F90FLAGS $PATH" | tr '"' ' '` > if uname -srm >/dev/null 2>&1 ; then > cache_system_text="`uname -srm` $cleanargs" > else > cache_system_text="-no-uname- $cleanargs" > fi > cache_system_ok=no > # > if test -z "$real_enable_cache" ; then > real_enable_cache=$enable_cache > if test -z "$real_enable_cache" ; then real_enable_cache="notgiven" ; fi > fi > if test "X$real_enable_cache" = "Xnotgiven" ; then > # check for valid cache file > if test -z "$cache_system" ; then cache_system="config.system" ; fi > if uname -srm >/dev/null 2>&1 ; then > if test -f "$cache_system" -a -n "$cache_system_text" ; then > if test "$cache_system_text" = "`cat $cache_system`" ; then > real_enable_cache="yes" > cache_system_ok=yes > fi > elif test ! -f "$cache_system" -a -n "$cache_system_text" ; then > # remove the cache file because it may not correspond to our > # system > if test "$cache_file" != "/dev/null" ; then > rm -f $cache_file > fi > real_enable_cache="yes" > fi > fi > fi > if test "X$real_enable_cache" = "Xyes" -a "$cache_file" = "/dev/null" ; then > real_enable_cache=no > fi > if test "X$real_enable_cache" = "Xyes" ; then > if test -r "$cache_file" ; then > echo "loading cache $cache_file" > if test -w "$cache_file" ; then > # Clean the cache file (ergh) > > rm -f confcache > sed -e "s/'\\\\''//g" -e "s/'\\\\/'/" -e "s/\\\\'/'/" \ > -e "s/'\\\\''//g" $cache_file > confcache > if cmp -s $cache_file confcache ; then > : > else > if test -w $cache_file ; then > echo "updating cache $cache_file" > cat confcache > $cache_file > else > echo "not updating unwritable cache $cache_file" > fi > fi > rm -f confcache > if test "$DEBUG_AUTOCONF_CACHE" = "yes" ; then > echo "Results of cleaned cache file:" > echo "--------------------------------------------------------" > cat $cache_file > echo "--------------------------------------------------------" > fi > > fi > . $cache_file > else > echo "Configure in `pwd` creating cache $cache_file" > > $cache_file > rm -f $cache_system > fi > else > cache_file="/dev/null" > fi > # Remember our location and the name of the cachefile > pac_cv_my_conf_dir=`pwd` > # > # Update the cache_system file if necessary > if test "$cache_system_ok" != yes ; then > if test -n "$cache_system" ; then > rm -f $cache_system > echo $cache_system_text > $cache_system > fi > fi > if test "$clearMinusX" = yes ; then > set +x > fi > > # Check that the precious variables saved in the cache have kept the same > # value. > ac_cache_corrupted=false > for ac_var in `(set) 2>&1 | > sed -n 's/^ac_env_\([a-zA-Z_0-9]*\)_set=.*/\1/p'`; do > eval ac_old_set=\$ac_cv_env_${ac_var}_set > eval ac_new_set=\$ac_env_${ac_var}_set > eval ac_old_val="\$ac_cv_env_${ac_var}_value" > eval ac_new_val="\$ac_env_${ac_var}_value" > case $ac_old_set,$ac_new_set in > set,) > { echo "$as_me:$LINENO: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5 > echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;} > ac_cache_corrupted=: ;; > ,set) > { echo "$as_me:$LINENO: error: \`$ac_var' was not set in the previous run" >&5 > echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;} > ac_cache_corrupted=: ;; > ,);; > *) > if test "x$ac_old_val" != "x$ac_new_val"; then > { echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5 > echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;} > { echo "$as_me:$LINENO: former value: $ac_old_val" >&5 > echo "$as_me: former value: $ac_old_val" >&2;} > { echo "$as_me:$LINENO: current value: $ac_new_val" >&5 > echo "$as_me: current value: $ac_new_val" >&2;} > ac_cache_corrupted=: > fi;; > esac > # Pass precious variables to config.status. > if test "$ac_new_set" = set; then > case $ac_new_val in > *" "*|*" "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*) > ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;; > *) ac_arg=$ac_var=$ac_new_val ;; > esac > case " $ac_configure_args " in > *" '$ac_arg' "*) ;; # Avoid dups. Use of quotes ensures accuracy. > *) ac_configure_args="$ac_configure_args '$ac_arg'" ;; > esac > fi > done > if $ac_cache_corrupted; then > { echo "$as_me:$LINENO: error: changes in the environment can compromise the build" >&5 > echo "$as_me: error: changes in the environment can compromise the build" >&2;} > { { echo "$as_me:$LINENO: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&5 > echo "$as_me: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&2;} > { (exit 1); exit 1; }; } > fi > > ac_ext=c > ac_cpp='$CPP $CPPFLAGS' > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' > ac_compiler_gnu=$ac_cv_c_compiler_gnu > > > > > > > > > > > > > > > > > > > > > if test -f $CONFIG_AUX_DIR/install-sh ; then ac_aux_dir=$CONFIG_AUX_DIR > else > ac_aux_dir= > # We force the test to use the absolute path to ensure that the install > # program can be used if we cd to a different directory before using > # install. > for ac_dir in ../../../confdb $srcdir/../../../confdb; do > if test -f $ac_dir/install-sh; then > ac_aux_dir=$ac_dir > abs_ac_aux_dir=`(cd $ac_aux_dir && pwd)` > ac_install_sh="$abs_ac_aux_dir/install-sh -c" > break > elif test -f $ac_dir/install.sh; then > ac_aux_dir=$ac_dir > abs_ac_aux_dir=`(cd $ac_aux_dir && pwd)` > ac_install_sh="$abs_ac_aux_dir/install.sh -c" > break > fi > done > fi > if test -z "$ac_aux_dir"; then > { { echo "$as_me:$LINENO: error: can not find install-sh or install.sh in ../../../confdb $srcdir/../../../confdb" >&5 > echo "$as_me: error: can not find install-sh or install.sh in ../../../confdb $srcdir/../../../confdb" >&2;} > { (exit 1); exit 1; }; } > fi > ac_config_guess=$ac_aux_dir/config.guess > ac_config_sub=$ac_aux_dir/config.sub > ac_configure=$ac_aux_dir/configure # This should be Cygnus configure. > > > ac_config_headers="$ac_config_headers include/mpid_config.h" > > > echo "RUNNING CONFIGURE FOR DCMF DEVICE" > > if test "`cd $srcdir && pwd`" != "`pwd`" && \ > test -f $srcdir/config.status ; then > { { echo "$as_me:$LINENO: error: You cannot do a VPATH build if the source directory has been > configured. Run \"make distclean\" in $srcdir first." >&5 > echo "$as_me: error: You cannot do a VPATH build if the source directory has been > configured. Run \"make distclean\" in $srcdir first." >&2;} > { (exit 1); exit 1; }; } > fi > > > # Check whether --enable-cache or --disable-cache was given. > if test "${enable_cache+set}" = set; then > enableval="$enable_cache" > enable_cache="$enableval" > else > enable_cache="notgiven" > fi; > > if test "$CONFIGURE_DEBUG_CACHE" = yes ; then > oldopts="$-" > clearMinusX=no > set -x > if test "$oldopts" != "$-" ; then > clearMinusX=yes > fi > fi > if test "X$cache_system" = "X" ; then > # A default file name, just in case > cache_system="config.system" > if test "$cache_file" != "/dev/null" ; then > # Get the directory for the cache file, if any > > cache_system=`echo $cache_file | sed -e 's%^\(.*/\)[^/]*%\1config.system%'` > > test "x$cache_system" = "x$cache_file" && cache_system="config.system" > # else > # We must *not* set enable_cache to no because we need to know if > # enable_cache was not set. > # enable_cache=no > fi > fi > # > # Get a test value and flag whether we should remove/replace the > # cache_system file (do so unless cache_system_ok is yes) > # FC and F77 should be synonyms. Save both in case > # We include the xxxFLAGS in case the user is using the flags to change > # the language (either input or output) of the compiler. E.g., > # using -xarch=v9 on Solaris to select 64 bit output or using -D_BSD_SOURCE > # with gcc to get different header files on input. > cleanargs=`echo "$CC $F77 $FC $CXX $F90 $CFLAGS $FFLAGS $CXXFLAGS $F90FLAGS $PATH" | tr '"' ' '` > if uname -srm >/dev/null 2>&1 ; then > cache_system_text="`uname -srm` $cleanargs" > else > cache_system_text="-no-uname- $cleanargs" > fi > cache_system_ok=no > # > if test -z "$real_enable_cache" ; then > real_enable_cache=$enable_cache > if test -z "$real_enable_cache" ; then real_enable_cache="notgiven" ; fi > fi > if test "X$real_enable_cache" = "Xnotgiven" ; then > # check for valid cache file > if test -z "$cache_system" ; then cache_system="config.system" ; fi > if uname -srm >/dev/null 2>&1 ; then > if test -f "$cache_system" -a -n "$cache_system_text" ; then > if test "$cache_system_text" = "`cat $cache_system`" ; then > real_enable_cache="yes" > cache_system_ok=yes > fi > elif test ! -f "$cache_system" -a -n "$cache_system_text" ; then > # remove the cache file because it may not correspond to our > # system > if test "$cache_file" != "/dev/null" ; then > rm -f $cache_file > fi > real_enable_cache="yes" > fi > fi > fi > if test "X$real_enable_cache" = "Xyes" -a "$cache_file" = "/dev/null" ; then > real_enable_cache=no > fi > if test "X$real_enable_cache" = "Xyes" ; then > if test -r "$cache_file" ; then > echo "loading cache $cache_file" > if test -w "$cache_file" ; then > # Clean the cache file (ergh) > > rm -f confcache > sed -e "s/'\\\\''//g" -e "s/'\\\\/'/" -e "s/\\\\'/'/" \ > -e "s/'\\\\''//g" $cache_file > confcache > if cmp -s $cache_file confcache ; then > : > else > if test -w $cache_file ; then > echo "updating cache $cache_file" > cat confcache > $cache_file > else > echo "not updating unwritable cache $cache_file" > fi > fi > rm -f confcache > if test "$DEBUG_AUTOCONF_CACHE" = "yes" ; then > echo "Results of cleaned cache file:" > echo "--------------------------------------------------------" > cat $cache_file > echo "--------------------------------------------------------" > fi > > fi > . $cache_file > else > echo "Configure in `pwd` creating cache $cache_file" > > $cache_file > rm -f $cache_system > fi > else > cache_file="/dev/null" > fi > # Remember our location and the name of the cachefile > pac_cv_my_conf_dir=`pwd` > # > # Update the cache_system file if necessary > if test "$cache_system_ok" != yes ; then > if test -n "$cache_system" ; then > rm -f $cache_system > echo $cache_system_text > $cache_system > fi > fi > if test "$clearMinusX" = yes ; then > set +x > fi > > > true > if test "X$MAKE" = "X" ; then > for ac_prog in make gnumake nmake pmake smake > do > # Extract the first word of "$ac_prog", so it can be a program name with args. > set dummy $ac_prog; ac_word=$2 > echo "$as_me:$LINENO: checking for $ac_word" >&5 > echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6 > if test "${ac_cv_prog_MAKE+set}" = set; then > echo $ECHO_N "(cached) $ECHO_C" >&6 > else > if test -n "$MAKE"; then > ac_cv_prog_MAKE="$MAKE" # Let the user override the test. > else > as_save_IFS=$IFS; IFS=$PATH_SEPARATOR > for as_dir in $PATH > do > IFS=$as_save_IFS > test -z "$as_dir" && as_dir=. > for ac_exec_ext in '' $ac_executable_extensions; do > if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then > ac_cv_prog_MAKE="$ac_prog" > echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 > break 2 > fi > done > done > > fi > fi > MAKE=$ac_cv_prog_MAKE > if test -n "$MAKE"; then > echo "$as_me:$LINENO: result: $MAKE" >&5 > echo "${ECHO_T}$MAKE" >&6 > else > echo "$as_me:$LINENO: result: no" >&5 > echo "${ECHO_T}no" >&6 > fi > > test -n "$MAKE" && break > done > > fi > > > echo "$as_me:$LINENO: checking whether clock skew breaks make" >&5 > echo $ECHO_N "checking whether clock skew breaks make... $ECHO_C" >&6 > if test "${pac_cv_prog_make_found_clock_skew+set}" = set; then > echo $ECHO_N "(cached) $ECHO_C" >&6 > else > > > rm -f conftest* > cat > conftest < ALL: > @-echo "success" > EOF > $MAKE -f conftest > conftest.out 2>&1 > if grep -i skew conftest >/dev/null 2>&1 ; then > pac_cv_prog_make_found_clock_skew=yes > else > pac_cv_prog_make_found_clock_skew=no > fi > rm -f conftest* > > fi > echo "$as_me:$LINENO: result: $pac_cv_prog_make_found_clock_skew" >&5 > echo "${ECHO_T}$pac_cv_prog_make_found_clock_skew" >&6 > if test "$pac_cv_prog_make_found_clock_skew" = "yes" ; then > { echo "$as_me:$LINENO: WARNING: Clock skew found by make. The configure and build may fail. > Consider building in a local instead of NFS filesystem." >&5 > echo "$as_me: WARNING: Clock skew found by make. The configure and build may fail. > Consider building in a local instead of NFS filesystem." >&2;} > fi > > > echo "$as_me:$LINENO: checking whether make supports include" >&5 > echo $ECHO_N "checking whether make supports include... $ECHO_C" >&6 > if test "${pac_cv_prog_make_include+set}" = set; then > echo $ECHO_N "(cached) $ECHO_C" >&6 > else > > > rm -f conftest > cat > conftest <<. > ALL: > @echo "success" > . > cat > conftest1 <<. > include conftest > . > pac_str=`$MAKE -f conftest1 2>&1` > rm -f conftest conftest1 > if test "$pac_str" != "success" ; then > pac_cv_prog_make_include="no" > else > pac_cv_prog_make_include="yes" > fi > > fi > echo "$as_me:$LINENO: result: $pac_cv_prog_make_include" >&5 > echo "${ECHO_T}$pac_cv_prog_make_include" >&6 > if test "$pac_cv_prog_make_include" = "no" ; then > : > else > : > fi > > > echo "$as_me:$LINENO: checking whether make allows comments in actions" >&5 > echo $ECHO_N "checking whether make allows comments in actions... $ECHO_C" >&6 > if test "${pac_cv_prog_make_allows_comments+set}" = set; then > echo $ECHO_N "(cached) $ECHO_C" >&6 > else > > > rm -f conftest > cat > conftest <<. > SHELL=/bin/sh > ALL: > @# This is a valid comment! > @echo "success" > . > pac_str=`$MAKE -f conftest 2>&1` > rm -f conftest > if test "$pac_str" != "success" ; then > pac_cv_prog_make_allows_comments="no" > else > pac_cv_prog_make_allows_comments="yes" > fi > > fi > echo "$as_me:$LINENO: result: $pac_cv_prog_make_allows_comments" >&5 > echo "${ECHO_T}$pac_cv_prog_make_allows_comments" >&6 > if test "$pac_cv_prog_make_allows_comments" = "no" ; then > { echo "$as_me:$LINENO: WARNING: Your make does not allow comments in target code. > Using this make may cause problems when building programs. > You should consider using gnumake instead." >&5 > echo "$as_me: WARNING: Your make does not allow comments in target code. > Using this make may cause problems when building programs. > You should consider using gnumake instead." >&2;} > > fi > > > > echo "$as_me:$LINENO: checking for virtual path format" >&5 > echo $ECHO_N "checking for virtual path format... $ECHO_C" >&6 > if test "${pac_cv_prog_make_vpath+set}" = set; then > echo $ECHO_N "(cached) $ECHO_C" >&6 > else > > > rm -rf conftest* > mkdir conftestdir > cat >conftestdir/a.c < A sample file > EOF > cat > conftest < all: a.o > VPATH=.:conftestdir > .c.o: > @echo \$< > EOF > ac_out=`$MAKE -f conftest 2>&1 | grep 'conftestdir/a.c'` > if test -n "$ac_out" ; then > pac_cv_prog_make_vpath="VPATH" > else > rm -f conftest > cat > conftest < all: a.o > .PATH: . conftestdir > .c.o: > @echo \$< > EOF > ac_out=`$MAKE -f conftest 2>&1 | grep 'conftestdir/a.c'` > if test -n "$ac_out" ; then > pac_cv_prog_make_vpath=".PATH" > else > pac_cv_prog_make_vpath="neither VPATH nor .PATH works" > fi > fi > rm -rf conftest* > > fi > echo "$as_me:$LINENO: result: $pac_cv_prog_make_vpath" >&5 > echo "${ECHO_T}$pac_cv_prog_make_vpath" >&6 > if test "$pac_cv_prog_make_vpath" = "VPATH" ; then > VPATH='VPATH=.:${srcdir}' > elif test "$pac_cv_prog_make_vpath" = ".PATH" ; then > VPATH='.PATH: . ${srcdir}' > fi > > > > echo "$as_me:$LINENO: checking whether make sets CFLAGS" >&5 > echo $ECHO_N "checking whether make sets CFLAGS... $ECHO_C" >&6 > if test "${pac_cv_prog_make_set_cflags+set}" = set; then > echo $ECHO_N "(cached) $ECHO_C" >&6 > else > > > rm -f conftest > cat > conftest < SHELL=/bin/sh > ALL: > @echo X\${CFLAGS}X > EOF > pac_str=`$MAKE -f conftest 2>&1` > rm -f conftest > if test "$pac_str" = "XX" ; then > pac_cv_prog_make_set_cflags="no" > else > pac_cv_prog_make_set_cflags="yes" > fi > > fi > echo "$as_me:$LINENO: result: $pac_cv_prog_make_set_cflags" >&5 > echo "${ECHO_T}$pac_cv_prog_make_set_cflags" >&6 > if test "$pac_cv_prog_make_set_cflags" = "no" ; then > : > else > SET_CFLAGS='CFLAGS=' > fi > > if test "$pac_cv_prog_make_echos_dir" = "no" ; then > echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5 > echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6 > set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,:./+-,___p_,'` > if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then > echo $ECHO_N "(cached) $ECHO_C" >&6 > else > cat >conftest.make <<\_ACEOF > all: > @echo 'ac_maketemp="$(MAKE)"' > _ACEOF > # GNU make sometimes prints "make[1]: Entering...", which would confuse us. > eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=` > if test -n "$ac_maketemp"; then > eval ac_cv_prog_make_${ac_make}_set=yes > else > eval ac_cv_prog_make_${ac_make}_set=no > fi > rm -f conftest.make > fi > if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then > echo "$as_me:$LINENO: result: yes" >&5 > echo "${ECHO_T}yes" >&6 > SET_MAKE= > else > echo "$as_me:$LINENO: result: no" >&5 > echo "${ECHO_T}no" >&6 > SET_MAKE="MAKE=${MAKE-make}" > fi > > else > SET_MAKE="MAKE=${MAKE-make}" > fi > > > > ASSERT_LEVEL=2 > > # Check whether --with-assert-level or --without-assert-level was given. > if test "${with_assert_level+set}" = set; then > withval="$with_assert_level" > ASSERT_LEVEL=$withval > fi; > > > cat >>confdefs.h <<_ACEOF > #define ASSERT_LEVEL $ASSERT_LEVEL > _ACEOF > > > > # > # bring in the default implementation of the MPID_Thread package > # > MPID_THREAD_SRCDIR="../common/thread" > if test "$MPICH_THREAD_LEVEL" = "MPI_THREAD_SINGLE" -o "$MPICH_THREAD_LEVEL" = "MPI_THREAD_FUNNELED" ; then > MPID_THREAD_TYPEDEFS="/dev/null" > MPID_THREAD_FUNCS="/dev/null" > MPI_THREAD_SOURCE_FILES="" > MPI_THREAD_OUTPUT_FILES="" > else > MPID_THREAD_IMPL_SRCDIR="${MPID_THREAD_IMPL_SRCDIR:-$srcdir/$MPID_THREAD_SRCDIR}" > MPID_THREAD_IMPL_PACKAGE="${MPID_THREAD_IMPL_PACKAGE:-mpe}" > > MPID_THREAD_TYPEDEFS="$MPID_THREAD_IMPL_SRCDIR/${MPID_THREAD_IMPL_PACKAGE}_types.i" > MPID_THREAD_FUNCS="$MPID_THREAD_IMPL_SRCDIR/${MPID_THREAD_IMPL_PACKAGE}_funcs.i" > > MPID_THREAD_SOURCE_FILES="mpid_thread.c:$MPID_THREAD_IMPL_SRCDIR/mpid_thread_${MPID_THREAD_IMPL_PACKAGE}.c" > > MPID_THREAD_DISTCLEAN_FILES="include/mpid_thread.h src/mpid_thread.c" > > MPID_THREAD_OUTPUT_FILES="include/mpid_thread.h:$MPID_THREAD_SRCDIR/mpid_thread.h.in" > fi > > > > > > > for entry in $MPID_THREAD_SOURCE_FILES ; do > destfile=`echo $entry | sed -e 's/:.*$//'` > MPID_THREAD_SOURCES="$MPID_THREAD_SOURCES $destfile" > done > > ac_config_commands="$ac_config_commands default-1" > > > > > > > > > > > > > > > > > > > INSTALL="/usr/bin/install -c" > INSTALL_PROGRAM="${INSTALL}" > INSTALL_DATA="${INSTALL} -m 644" > > > > > > FILE=`cd $srcdir && find -name Makefile.in | perl -pe 's,^\./,,;s/\.in$//'` > ac_config_files="$ac_config_files localdefs $MPID_THREAD_OUTPUT_FILES $FILE" > cat >confcache <<\_ACEOF > # This file is a shell script that caches the results of configure > # tests run on this system so they can be shared between configure > # scripts and configure runs, see configure's option --config-cache. > # It is not useful on other systems. If it contains results you don't > # want to keep, you may remove or edit it. > # > # config.status only pays attention to the cache file if you give it > # the --recheck option to rerun configure. > # > # `ac_cv_env_foo' variables (set or unset) will be overridden when > # loading this file, other *unset* `ac_cv_foo' will be assigned the > # following values. > > _ACEOF > > # The following way of writing the cache mishandles newlines in values, > # but we know of no workaround that is simple, portable, and efficient. > # So, don't put newlines in cache variables' values. > # Ultrix sh set writes to stderr and can't be redirected directly, > # and sets the high bit in the cache file unless we assign to the vars. > { > (set) 2>&1 | > case `(ac_space=' '; set | grep ac_space) 2>&1` in > *ac_space=\ *) > # `set' does not quote correctly, so add quotes (double-quote > # substitution turns \\\\ into \\, and sed turns \\ into \). > sed -n \ > "s/'/'\\\\''/g; > s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p" > ;; > *) > # `set' quotes correctly as required by POSIX, so do not add quotes. > sed -n \ > "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p" > ;; > esac; > } | > sed ' > t clear > : clear > s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/ > t end > /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/ > : end' >>confcache > if diff $cache_file confcache >/dev/null 2>&1; then :; else > if test -w $cache_file; then > test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file" > cat confcache >$cache_file > else > echo "not updating unwritable cache $cache_file" > fi > fi > rm -f confcache > > test "x$prefix" = xNONE && prefix=$ac_default_prefix > # Let make expand exec_prefix. > test "x$exec_prefix" = xNONE && exec_prefix='${prefix}' > > # VPATH may cause trouble with some makes, so we remove $(srcdir), > # ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and > # trailing colons and then remove the whole line if VPATH becomes empty > # (actually we leave an empty line to preserve line numbers). > if test "x$srcdir" = x.; then > ac_vpsub='/^[ ]*VPATH[ ]*=/{ > s/:*\$(srcdir):*/:/; > s/:*\${srcdir}:*/:/; > s/:*@srcdir@:*/:/; > s/^\([^=]*=[ ]*\):*/\1/; > s/:*$//; > s/^[^=]*=[ ]*$//; > }' > fi > > DEFS=-DHAVE_CONFIG_H > > ac_libobjs= > ac_ltlibobjs= > for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue > # 1. Remove the extension, and $U if already installed. > ac_i=`echo "$ac_i" | > sed 's/\$U\././;s/\.o$//;s/\.obj$//'` > # 2. Add them. > ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext" > ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo' > done > LIBOBJS=$ac_libobjs > > LTLIBOBJS=$ac_ltlibobjs > > > > : ${CONFIG_STATUS=./config.status} > ac_clean_files_save=$ac_clean_files > ac_clean_files="$ac_clean_files $CONFIG_STATUS" > { echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5 > echo "$as_me: creating $CONFIG_STATUS" >&6;} > cat >$CONFIG_STATUS <<_ACEOF > #! $SHELL > # Generated by $as_me. > # Run this file to recreate the current configuration. > # Compiler output produced by configure, useful for debugging > # configure, is in config.log if it exists. > > debug=false > ac_cs_recheck=false > ac_cs_silent=false > SHELL=\${CONFIG_SHELL-$SHELL} > _ACEOF > > cat >>$CONFIG_STATUS <<\_ACEOF > ## --------------------- ## > ## M4sh Initialization. ## > ## --------------------- ## > > # Be Bourne compatible > if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then > emulate sh > NULLCMD=: > # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which > # is contrary to our usage. Disable this feature. > alias -g '${1+"$@"}'='"$@"' > elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then > set -o posix > fi > DUALCASE=1; export DUALCASE # for MKS sh > > # Support unset when possible. > if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then > as_unset=unset > else > as_unset=false > fi > > > # Work around bugs in pre-3.0 UWIN ksh. > $as_unset ENV MAIL MAILPATH > PS1='$ ' > PS2='> ' > PS4='+ ' > > # NLS nuisances. > for as_var in \ > LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \ > LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \ > LC_TELEPHONE LC_TIME > do > if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then > eval $as_var=C; export $as_var > else > $as_unset $as_var > fi > done > > # Required to use basename. > if expr a : '\(a\)' >/dev/null 2>&1; then > as_expr=expr > else > as_expr=false > fi > > if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then > as_basename=basename > else > as_basename=false > fi > > > # Name of the executable. > as_me=`$as_basename "$0" || > $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \ > X"$0" : 'X\(//\)$' \| \ > X"$0" : 'X\(/\)$' \| \ > . : '\(.\)' 2>/dev/null || > echo X/"$0" | > sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; } > /^X\/\(\/\/\)$/{ s//\1/; q; } > /^X\/\(\/\).*/{ s//\1/; q; } > s/.*/./; q'` > > > # PATH needs CR, and LINENO needs CR and PATH. > # Avoid depending upon Character Ranges. > as_cr_letters='abcdefghijklmnopqrstuvwxyz' > as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ' > as_cr_Letters=$as_cr_letters$as_cr_LETTERS > as_cr_digits='0123456789' > as_cr_alnum=$as_cr_Letters$as_cr_digits > > # The user is always right. > if test "${PATH_SEPARATOR+set}" != set; then > echo "#! /bin/sh" >conf$$.sh > echo "exit 0" >>conf$$.sh > chmod +x conf$$.sh > if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then > PATH_SEPARATOR=';' > else > PATH_SEPARATOR=: > fi > rm -f conf$$.sh > fi > > > as_lineno_1=$LINENO > as_lineno_2=$LINENO > as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null` > test "x$as_lineno_1" != "x$as_lineno_2" && > test "x$as_lineno_3" = "x$as_lineno_2" || { > # Find who we are. Look in the path if we contain no path at all > # relative or not. > case $0 in > *[\\/]* ) as_myself=$0 ;; > *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR > for as_dir in $PATH > do > IFS=$as_save_IFS > test -z "$as_dir" && as_dir=. > test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break > done > > ;; > esac > # We did not find ourselves, most probably we were run as `sh COMMAND' > # in which case we are not to be found in the path. > if test "x$as_myself" = x; then > as_myself=$0 > fi > if test ! -f "$as_myself"; then > { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5 > echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;} > { (exit 1); exit 1; }; } > fi > case $CONFIG_SHELL in > '') > as_save_IFS=$IFS; IFS=$PATH_SEPARATOR > for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH > do > IFS=$as_save_IFS > test -z "$as_dir" && as_dir=. > for as_base in sh bash ksh sh5; do > case $as_dir in > /*) > if ("$as_dir/$as_base" -c ' > as_lineno_1=$LINENO > as_lineno_2=$LINENO > as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null` > test "x$as_lineno_1" != "x$as_lineno_2" && > test "x$as_lineno_3" = "x$as_lineno_2" ') 2>/dev/null; then > $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; } > $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; } > CONFIG_SHELL=$as_dir/$as_base > export CONFIG_SHELL > exec "$CONFIG_SHELL" "$0" ${1+"$@"} > fi;; > esac > done > done > ;; > esac > > # Create $as_me.lineno as a copy of $as_myself, but with $LINENO > # uniformly replaced by the line number. The first 'sed' inserts a > # line-number line before each line; the second 'sed' does the real > # work. The second script uses 'N' to pair each line-number line > # with the numbered line, and appends trailing '-' during > # substitution so that $LINENO is not a special case at line end. > # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the > # second 'sed' script. Blame Lee E. McMahon for sed's syntax. :-) > sed '=' <$as_myself | > sed ' > N > s,$,-, > : loop > s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3, > t loop > s,-$,, > s,^['$as_cr_digits']*\n,, > ' >$as_me.lineno && > chmod +x $as_me.lineno || > { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5 > echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;} > { (exit 1); exit 1; }; } > > # Don't try to exec as it changes $[0], causing all sort of problems > # (the dirname of $[0] is not the place where we might find the > # original and so on. Autoconf is especially sensible to this). > . ./$as_me.lineno > # Exit status is that of the last command. > exit > } > > > case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in > *c*,-n*) ECHO_N= ECHO_C=' > ' ECHO_T=' ' ;; > *c*,* ) ECHO_N=-n ECHO_C= ECHO_T= ;; > *) ECHO_N= ECHO_C='\c' ECHO_T= ;; > esac > > if expr a : '\(a\)' >/dev/null 2>&1; then > as_expr=expr > else > as_expr=false > fi > > rm -f conf$$ conf$$.exe conf$$.file > echo >conf$$.file > if ln -s conf$$.file conf$$ 2>/dev/null; then > # We could just check for DJGPP; but this test a) works b) is more generic > # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04). > if test -f conf$$.exe; then > # Don't use ln at all; we don't have any links > as_ln_s='cp -p' > else > as_ln_s='ln -s' > fi > elif ln conf$$.file conf$$ 2>/dev/null; then > as_ln_s=ln > else > as_ln_s='cp -p' > fi > rm -f conf$$ conf$$.exe conf$$.file > > if mkdir -p . 2>/dev/null; then > as_mkdir_p=: > else > test -d ./-p && rmdir ./-p > as_mkdir_p=false > fi > > as_executable_p="test -f" > > # Sed expression to map a string onto a valid CPP name. > as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'" > > # Sed expression to map a string onto a valid variable name. > as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'" > > > # IFS > # We need space, tab and new line, in precisely that order. > as_nl=' > ' > IFS=" $as_nl" > > # CDPATH. > $as_unset CDPATH > > exec 6>&1 > > # Open the log real soon, to keep \$[0] and so on meaningful, and to > # report actual input values of CONFIG_FILES etc. instead of their > # values after options handling. Logging --version etc. is OK. > exec 5>>config.log > { > echo > sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX > ## Running $as_me. ## > _ASBOX > } >&5 > cat >&5 <<_CSEOF > > This file was extended by $as_me, which was > generated by GNU Autoconf 2.59. Invocation command line was > > CONFIG_FILES = $CONFIG_FILES > CONFIG_HEADERS = $CONFIG_HEADERS > CONFIG_LINKS = $CONFIG_LINKS > CONFIG_COMMANDS = $CONFIG_COMMANDS > $ $0 $@ > > _CSEOF > echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5 > echo >&5 > _ACEOF > > # Files that config.status was made for. > if test -n "$ac_config_files"; then > echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS > fi > > if test -n "$ac_config_headers"; then > echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS > fi > > if test -n "$ac_config_links"; then > echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS > fi > > if test -n "$ac_config_commands"; then > echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS > fi > > cat >>$CONFIG_STATUS <<\_ACEOF > > ac_cs_usage="\ > \`$as_me' instantiates files from templates according to the > current configuration. > > Usage: $0 [OPTIONS] [FILE]... > > -h, --help print this help, then exit > -V, --version print version number, then exit > -q, --quiet do not print progress messages > -d, --debug don't remove temporary files > --recheck update $as_me by reconfiguring in the same conditions > --file=FILE[:TEMPLATE] > instantiate the configuration file FILE > --header=FILE[:TEMPLATE] > instantiate the configuration header FILE > > Configuration files: > $config_files > > Configuration headers: > $config_headers > > Configuration commands: > $config_commands > > Report bugs to ." > _ACEOF > > cat >>$CONFIG_STATUS <<_ACEOF > ac_cs_version="\\ > config.status > configured by $0, generated by GNU Autoconf 2.59, > with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\" > > Copyright (C) 2003 Free Software Foundation, Inc. > This config.status script is free software; the Free Software Foundation > gives unlimited permission to copy, distribute and modify it." > srcdir=$srcdir > _ACEOF > > cat >>$CONFIG_STATUS <<\_ACEOF > # If no file are specified by the user, then we need to provide default > # value. By we need to know if files were specified by the user. > ac_need_defaults=: > while test $# != 0 > do > case $1 in > --*=*) > ac_option=`expr "x$1" : 'x\([^=]*\)='` > ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'` > ac_shift=: > ;; > -*) > ac_option=$1 > ac_optarg=$2 > ac_shift=shift > ;; > *) # This is not an option, so the user has probably given explicit > # arguments. > ac_option=$1 > ac_need_defaults=false;; > esac > > case $ac_option in > # Handling of the options. > _ACEOF > cat >>$CONFIG_STATUS <<\_ACEOF > -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r) > ac_cs_recheck=: ;; > --version | --vers* | -V ) > echo "$ac_cs_version"; exit 0 ;; > --he | --h) > # Conflict between --help and --header > { { echo "$as_me:$LINENO: error: ambiguous option: $1 > Try \`$0 --help' for more information." >&5 > echo "$as_me: error: ambiguous option: $1 > Try \`$0 --help' for more information." >&2;} > { (exit 1); exit 1; }; };; > --help | --hel | -h ) > echo "$ac_cs_usage"; exit 0 ;; > --debug | --d* | -d ) > debug=: ;; > --file | --fil | --fi | --f ) > $ac_shift > CONFIG_FILES="$CONFIG_FILES $ac_optarg" > ac_need_defaults=false;; > --header | --heade | --head | --hea ) > $ac_shift > CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg" > ac_need_defaults=false;; > -q | -quiet | --quiet | --quie | --qui | --qu | --q \ > | -silent | --silent | --silen | --sile | --sil | --si | --s) > ac_cs_silent=: ;; > > # This is an error. > -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1 > Try \`$0 --help' for more information." >&5 > echo "$as_me: error: unrecognized option: $1 > Try \`$0 --help' for more information." >&2;} > { (exit 1); exit 1; }; } ;; > > *) ac_config_targets="$ac_config_targets $1" ;; > > esac > shift > done > > ac_configure_extra_args= > > if $ac_cs_silent; then > exec 6>/dev/null > ac_configure_extra_args="$ac_configure_extra_args --silent" > fi > > _ACEOF > cat >>$CONFIG_STATUS <<_ACEOF > if \$ac_cs_recheck; then > echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6 > exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion > fi > > _ACEOF > > cat >>$CONFIG_STATUS <<_ACEOF > # > # INIT-COMMANDS section. > # > > > MPID_THREAD_SOURCE_FILES=$MPID_THREAD_SOURCE_FILES > > > _ACEOF > > > > cat >>$CONFIG_STATUS <<\_ACEOF > for ac_config_target in $ac_config_targets > do > case "$ac_config_target" in > # Handling of arguments. > "localdefs" ) CONFIG_FILES="$CONFIG_FILES localdefs" ;; > "$MPID_THREAD_OUTPUT_FILES" ) CONFIG_FILES="$CONFIG_FILES $MPID_THREAD_OUTPUT_FILES" ;; > "$FILE" ) CONFIG_FILES="$CONFIG_FILES $FILE" ;; > "default-1" ) CONFIG_COMMANDS="$CONFIG_COMMANDS default-1" ;; > "include/mpid_config.h" ) CONFIG_HEADERS="$CONFIG_HEADERS include/mpid_config.h" ;; > *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5 > echo "$as_me: error: invalid argument: $ac_config_target" >&2;} > { (exit 1); exit 1; }; };; > esac > done > > # If the user did not use the arguments to specify the items to instantiate, > # then the envvar interface is used. Set only those that are not. > # We use the long form for the default assignment because of an extremely > # bizarre bug on SunOS 4.1.3. > if $ac_need_defaults; then > test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files > test "${CONFIG_HEADERS+set}" = set || CONFIG_HEADERS=$config_headers > test "${CONFIG_COMMANDS+set}" = set || CONFIG_COMMANDS=$config_commands > fi > > # Have a temporary directory for convenience. Make it in the build tree > # simply because there is no reason to put it here, and in addition, > # creating and moving files from /tmp can sometimes cause problems. > # Create a temporary directory, and hook for its removal unless debugging. > $debug || > { > trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0 > trap '{ (exit 1); exit 1; }' 1 2 13 15 > } > > # Create a (secure) tmp directory for tmp files. > > { > tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` && > test -n "$tmp" && test -d "$tmp" > } || > { > tmp=./confstat$$-$RANDOM > (umask 077 && mkdir $tmp) > } || > { > echo "$me: cannot create a temporary directory in ." >&2 > { (exit 1); exit 1; } > } > > _ACEOF > > cat >>$CONFIG_STATUS <<_ACEOF > > # > # CONFIG_FILES section. > # > > # No need to generate the scripts if there are no CONFIG_FILES. > # This happens for instance when ./config.status config.h > if test -n "\$CONFIG_FILES"; then > # Protect against being on the right side of a sed subst in config.status. > sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g; > s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF > s,@SHELL@,$SHELL,;t t > s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t > s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t > s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t > s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t > s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t > s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t > s,@exec_prefix@,$exec_prefix,;t t > s,@prefix@,$prefix,;t t > s,@program_transform_name@,$program_transform_name,;t t > s,@bindir@,$bindir,;t t > s,@sbindir@,$sbindir,;t t > s,@libexecdir@,$libexecdir,;t t > s,@datadir@,$datadir,;t t > s,@sysconfdir@,$sysconfdir,;t t > s,@sharedstatedir@,$sharedstatedir,;t t > s,@localstatedir@,$localstatedir,;t t > s,@libdir@,$libdir,;t t > s,@includedir@,$includedir,;t t > s,@oldincludedir@,$oldincludedir,;t t > s,@infodir@,$infodir,;t t > s,@mandir@,$mandir,;t t > s,@build_alias@,$build_alias,;t t > s,@host_alias@,$host_alias,;t t > s,@target_alias@,$target_alias,;t t > s,@DEFS@,$DEFS,;t t > s,@ECHO_C@,$ECHO_C,;t t > s,@ECHO_N@,$ECHO_N,;t t > s,@ECHO_T@,$ECHO_T,;t t > s,@LIBS@,$LIBS,;t t > s,@MAKE@,$MAKE,;t t > s,@VPATH@,$VPATH,;t t > s,@SET_CFLAGS@,$SET_CFLAGS,;t t > s,@SET_MAKE@,$SET_MAKE,;t t > s,@ASSERT_LEVEL@,$ASSERT_LEVEL,;t t > s,@MPID_THREAD_SOURCES@,$MPID_THREAD_SOURCES,;t t > s,@MPID_THREAD_DISTCLEAN@,$MPID_THREAD_DISTCLEAN,;t t > s,@AR@,$AR,;t t > s,@RANLIB@,$RANLIB,;t t > s,@MPILIBNAME@,$MPILIBNAME,;t t > s,@CC@,$CC,;t t > s,@CFLAGS@,$CFLAGS,;t t > s,@CPPFLAGS@,$CPPFLAGS,;t t > s,@CC_SHL@,$CC_SHL,;t t > s,@C_LINK_SHL@,$C_LINK_SHL,;t t > s,@master_top_srcdir@,$master_top_srcdir,;t t > s,@master_top_builddir@,$master_top_builddir,;t t > s,@MAKE_DEPEND_C@,$MAKE_DEPEND_C,;t t > s,@ENABLE_SHLIB@,$ENABLE_SHLIB,;t t > s,@MKDIR_P@,$MKDIR_P,;t t > s,@INSTALL@,$INSTALL,;t t > s,@INSTALL_DATA@,$INSTALL_DATA,;t t > s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t > s,@LIBOBJS@,$LIBOBJS,;t t > s,@LTLIBOBJS@,$LTLIBOBJS,;t t > /@MPID_THREAD_TYPEDEFS@/r $MPID_THREAD_TYPEDEFS > s,@MPID_THREAD_TYPEDEFS@,,;t t > /@MPID_THREAD_FUNCS@/r $MPID_THREAD_FUNCS > s,@MPID_THREAD_FUNCS@,,;t t > CEOF > > _ACEOF > > cat >>$CONFIG_STATUS <<\_ACEOF > # Split the substitutions into bite-sized pieces for seds with > # small command number limits, like on Digital OSF/1 and HP-UX. > ac_max_sed_lines=48 > ac_sed_frag=1 # Number of current file. > ac_beg=1 # First line for current file. > ac_end=$ac_max_sed_lines # Line after last line for current file. > ac_more_lines=: > ac_sed_cmds= > while $ac_more_lines; do > if test $ac_beg -gt 1; then > sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag > else > sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag > fi > if test ! -s $tmp/subs.frag; then > ac_more_lines=false > else > # The purpose of the label and of the branching condition is to > # speed up the sed processing (if there are no `@' at all, there > # is no need to browse any of the substitutions). > # These are the two extra sed commands mentioned above. > (echo ':t > /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed > if test -z "$ac_sed_cmds"; then > ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed" > else > ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed" > fi > ac_sed_frag=`expr $ac_sed_frag + 1` > ac_beg=$ac_end > ac_end=`expr $ac_end + $ac_max_sed_lines` > fi > done > if test -z "$ac_sed_cmds"; then > ac_sed_cmds=cat > fi > fi # test -n "$CONFIG_FILES" > > _ACEOF > cat >>$CONFIG_STATUS <<\_ACEOF > for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue > # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in". > case $ac_file in > - | *:- | *:-:* ) # input from stdin > cat >$tmp/stdin > ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'` > ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;; > *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'` > ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;; > * ) ac_file_in=$ac_file.in ;; > esac > > # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories. > ac_dir=`(dirname "$ac_file") 2>/dev/null || > $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ > X"$ac_file" : 'X\(//\)[^/]' \| \ > X"$ac_file" : 'X\(//\)$' \| \ > X"$ac_file" : 'X\(/\)' \| \ > . : '\(.\)' 2>/dev/null || > echo X"$ac_file" | > sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; } > /^X\(\/\/\)[^/].*/{ s//\1/; q; } > /^X\(\/\/\)$/{ s//\1/; q; } > /^X\(\/\).*/{ s//\1/; q; } > s/.*/./; q'` > { if $as_mkdir_p; then > mkdir -p "$ac_dir" > else > as_dir="$ac_dir" > as_dirs= > while test ! -d "$as_dir"; do > as_dirs="$as_dir $as_dirs" > as_dir=`(dirname "$as_dir") 2>/dev/null || > $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ > X"$as_dir" : 'X\(//\)[^/]' \| \ > X"$as_dir" : 'X\(//\)$' \| \ > X"$as_dir" : 'X\(/\)' \| \ > . : '\(.\)' 2>/dev/null || > echo X"$as_dir" | > sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; } > /^X\(\/\/\)[^/].*/{ s//\1/; q; } > /^X\(\/\/\)$/{ s//\1/; q; } > /^X\(\/\).*/{ s//\1/; q; } > s/.*/./; q'` > done > test ! -n "$as_dirs" || mkdir $as_dirs > fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5 > echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;} > { (exit 1); exit 1; }; }; } > > ac_builddir=. > > if test "$ac_dir" != .; then > ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'` > # A "../" for each directory in $ac_dir_suffix. > ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'` > else > ac_dir_suffix= ac_top_builddir= > fi > > case $srcdir in > .) # No --srcdir option. We are building in place. > ac_srcdir=. > if test -z "$ac_top_builddir"; then > ac_top_srcdir=. > else > ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'` > fi ;; > [\\/]* | ?:[\\/]* ) # Absolute path. > ac_srcdir=$srcdir$ac_dir_suffix; > ac_top_srcdir=$srcdir ;; > *) # Relative path. > ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix > ac_top_srcdir=$ac_top_builddir$srcdir ;; > esac > > # Do not use `cd foo && pwd` to compute absolute paths, because > # the directories may not exist. > case `pwd` in > .) ac_abs_builddir="$ac_dir";; > *) > case "$ac_dir" in > .) ac_abs_builddir=`pwd`;; > [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";; > *) ac_abs_builddir=`pwd`/"$ac_dir";; > esac;; > esac > case $ac_abs_builddir in > .) ac_abs_top_builddir=${ac_top_builddir}.;; > *) > case ${ac_top_builddir}. in > .) ac_abs_top_builddir=$ac_abs_builddir;; > [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;; > *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;; > esac;; > esac > case $ac_abs_builddir in > .) ac_abs_srcdir=$ac_srcdir;; > *) > case $ac_srcdir in > .) ac_abs_srcdir=$ac_abs_builddir;; > [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;; > *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;; > esac;; > esac > case $ac_abs_builddir in > .) ac_abs_top_srcdir=$ac_top_srcdir;; > *) > case $ac_top_srcdir in > .) ac_abs_top_srcdir=$ac_abs_builddir;; > [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;; > *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;; > esac;; > esac > > > > if test x"$ac_file" != x-; then > { echo "$as_me:$LINENO: creating $ac_file" >&5 > echo "$as_me: creating $ac_file" >&6;} > rm -f "$ac_file" > fi > # Let's still pretend it is `configure' which instantiates (i.e., don't > # use $as_me), people would be surprised to read: > # /* config.h. Generated by config.status. */ > if test x"$ac_file" = x-; then > configure_input= > else > configure_input="$ac_file. " > fi > configure_input=$configure_input"Generated from `echo $ac_file_in | > sed 's,.*/,,'` by configure." > > # First look for the input files in the build tree, otherwise in the > # src tree. > ac_file_inputs=`IFS=: > for f in $ac_file_in; do > case $f in > -) echo $tmp/stdin ;; > [\\/$]*) > # Absolute (can't be DOS-style, as IFS=:) > test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5 > echo "$as_me: error: cannot find input file: $f" >&2;} > { (exit 1); exit 1; }; } > echo "$f";; > *) # Relative > if test -f "$f"; then > # Build tree > echo "$f" > elif test -f "$srcdir/$f"; then > # Source tree > echo "$srcdir/$f" > else > # /dev/null tree > { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5 > echo "$as_me: error: cannot find input file: $f" >&2;} > { (exit 1); exit 1; }; } > fi;; > esac > done` || { (exit 1); exit 1; } > _ACEOF > cat >>$CONFIG_STATUS <<_ACEOF > sed "$ac_vpsub > $extrasub > _ACEOF > cat >>$CONFIG_STATUS <<\_ACEOF > :t > /@[a-zA-Z_][a-zA-Z_0-9]*@/!b > s,@configure_input@,$configure_input,;t t > s,@srcdir@,$ac_srcdir,;t t > s,@abs_srcdir@,$ac_abs_srcdir,;t t > s,@top_srcdir@,$ac_top_srcdir,;t t > s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t > s,@builddir@,$ac_builddir,;t t > s,@abs_builddir@,$ac_abs_builddir,;t t > s,@top_builddir@,$ac_top_builddir,;t t > s,@abs_top_builddir@,$ac_abs_top_builddir,;t t > " $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out > rm -f $tmp/stdin > if test x"$ac_file" != x-; then > mv $tmp/out $ac_file > else > cat $tmp/out > rm -f $tmp/out > fi > > done > _ACEOF > cat >>$CONFIG_STATUS <<\_ACEOF > > # > # CONFIG_HEADER section. > # > > # These sed commands are passed to sed as "A NAME B NAME C VALUE D", where > # NAME is the cpp macro being defined and VALUE is the value it is being given. > # > # ac_d sets the value in "#define NAME VALUE" lines. > ac_dA='s,^\([ ]*\)#\([ ]*define[ ][ ]*\)' > ac_dB='[ ].*$,\1#\2' > ac_dC=' ' > ac_dD=',;t' > # ac_u turns "#undef NAME" without trailing blanks into "#define NAME VALUE". > ac_uA='s,^\([ ]*\)#\([ ]*\)undef\([ ][ ]*\)' > ac_uB='$,\1#\2define\3' > ac_uC=' ' > ac_uD=',;t' > > for ac_file in : $CONFIG_HEADERS; do test "x$ac_file" = x: && continue > # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in". > case $ac_file in > - | *:- | *:-:* ) # input from stdin > cat >$tmp/stdin > ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'` > ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;; > *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'` > ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;; > * ) ac_file_in=$ac_file.in ;; > esac > > test x"$ac_file" != x- && { echo "$as_me:$LINENO: creating $ac_file" >&5 > echo "$as_me: creating $ac_file" >&6;} > > # First look for the input files in the build tree, otherwise in the > # src tree. > ac_file_inputs=`IFS=: > for f in $ac_file_in; do > case $f in > -) echo $tmp/stdin ;; > [\\/$]*) > # Absolute (can't be DOS-style, as IFS=:) > test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5 > echo "$as_me: error: cannot find input file: $f" >&2;} > { (exit 1); exit 1; }; } > # Do quote $f, to prevent DOS paths from being IFS'd. > echo "$f";; > *) # Relative > if test -f "$f"; then > # Build tree > echo "$f" > elif test -f "$srcdir/$f"; then > # Source tree > echo "$srcdir/$f" > else > # /dev/null tree > { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5 > echo "$as_me: error: cannot find input file: $f" >&2;} > { (exit 1); exit 1; }; } > fi;; > esac > done` || { (exit 1); exit 1; } > # Remove the trailing spaces. > sed 's/[ ]*$//' $ac_file_inputs >$tmp/in > > _ACEOF > > # Transform confdefs.h into two sed scripts, `conftest.defines' and > # `conftest.undefs', that substitutes the proper values into > # config.h.in to produce config.h. The first handles `#define' > # templates, and the second `#undef' templates. > # And first: Protect against being on the right side of a sed subst in > # config.status. Protect against being in an unquoted here document > # in config.status. > rm -f conftest.defines conftest.undefs > # Using a here document instead of a string reduces the quoting nightmare. > # Putting comments in sed scripts is not portable. > # > # `end' is used to avoid that the second main sed command (meant for > # 0-ary CPP macros) applies to n-ary macro definitions. > # See the Autoconf documentation for `clear'. > cat >confdef2sed.sed <<\_ACEOF > s/[\\&,]/\\&/g > s,[\\$`],\\&,g > t clear > : clear > s,^[ ]*#[ ]*define[ ][ ]*\([^ (][^ (]*\)\(([^)]*)\)[ ]*\(.*\)$,${ac_dA}\1${ac_dB}\1\2${ac_dC}\3${ac_dD},gp > t end > s,^[ ]*#[ ]*define[ ][ ]*\([^ ][^ ]*\)[ ]*\(.*\)$,${ac_dA}\1${ac_dB}\1${ac_dC}\2${ac_dD},gp > : end > _ACEOF > # If some macros were called several times there might be several times > # the same #defines, which is useless. Nevertheless, we may not want to > # sort them, since we want the *last* AC-DEFINE to be honored. > uniq confdefs.h | sed -n -f confdef2sed.sed >conftest.defines > sed 's/ac_d/ac_u/g' conftest.defines >conftest.undefs > rm -f confdef2sed.sed > > # This sed command replaces #undef with comments. This is necessary, for > # example, in the case of _POSIX_SOURCE, which is predefined and required > # on some systems where configure will not decide to define it. > cat >>conftest.undefs <<\_ACEOF > s,^[ ]*#[ ]*undef[ ][ ]*[a-zA-Z_][a-zA-Z_0-9]*,/* & */, > _ACEOF > > # Break up conftest.defines because some shells have a limit on the size > # of here documents, and old seds have small limits too (100 cmds). > echo ' # Handle all the #define templates only if necessary.' >>$CONFIG_STATUS > echo ' if grep "^[ ]*#[ ]*define" $tmp/in >/dev/null; then' >>$CONFIG_STATUS > echo ' # If there are no defines, we may have an empty if/fi' >>$CONFIG_STATUS > echo ' :' >>$CONFIG_STATUS > rm -f conftest.tail > while grep . conftest.defines >/dev/null > do > # Write a limited-size here document to $tmp/defines.sed. > echo ' cat >$tmp/defines.sed <>$CONFIG_STATUS > # Speed up: don't consider the non `#define' lines. > echo '/^[ ]*#[ ]*define/!b' >>$CONFIG_STATUS > # Work around the forget-to-reset-the-flag bug. > echo 't clr' >>$CONFIG_STATUS > echo ': clr' >>$CONFIG_STATUS > sed ${ac_max_here_lines}q conftest.defines >>$CONFIG_STATUS > echo 'CEOF > sed -f $tmp/defines.sed $tmp/in >$tmp/out > rm -f $tmp/in > mv $tmp/out $tmp/in > ' >>$CONFIG_STATUS > sed 1,${ac_max_here_lines}d conftest.defines >conftest.tail > rm -f conftest.defines > mv conftest.tail conftest.defines > done > rm -f conftest.defines > echo ' fi # grep' >>$CONFIG_STATUS > echo >>$CONFIG_STATUS > > # Break up conftest.undefs because some shells have a limit on the size > # of here documents, and old seds have small limits too (100 cmds). > echo ' # Handle all the #undef templates' >>$CONFIG_STATUS > rm -f conftest.tail > while grep . conftest.undefs >/dev/null > do > # Write a limited-size here document to $tmp/undefs.sed. > echo ' cat >$tmp/undefs.sed <>$CONFIG_STATUS > # Speed up: don't consider the non `#undef' > echo '/^[ ]*#[ ]*undef/!b' >>$CONFIG_STATUS > # Work around the forget-to-reset-the-flag bug. > echo 't clr' >>$CONFIG_STATUS > echo ': clr' >>$CONFIG_STATUS > sed ${ac_max_here_lines}q conftest.undefs >>$CONFIG_STATUS > echo 'CEOF > sed -f $tmp/undefs.sed $tmp/in >$tmp/out > rm -f $tmp/in > mv $tmp/out $tmp/in > ' >>$CONFIG_STATUS > sed 1,${ac_max_here_lines}d conftest.undefs >conftest.tail > rm -f conftest.undefs > mv conftest.tail conftest.undefs > done > rm -f conftest.undefs > > cat >>$CONFIG_STATUS <<\_ACEOF > # Let's still pretend it is `configure' which instantiates (i.e., don't > # use $as_me), people would be surprised to read: > # /* config.h. Generated by config.status. */ > if test x"$ac_file" = x-; then > echo "/* Generated by configure. */" >$tmp/config.h > else > echo "/* $ac_file. Generated by configure. */" >$tmp/config.h > fi > cat $tmp/in >>$tmp/config.h > rm -f $tmp/in > if test x"$ac_file" != x-; then > if diff $ac_file $tmp/config.h >/dev/null 2>&1; then > { echo "$as_me:$LINENO: $ac_file is unchanged" >&5 > echo "$as_me: $ac_file is unchanged" >&6;} > else > ac_dir=`(dirname "$ac_file") 2>/dev/null || > $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ > X"$ac_file" : 'X\(//\)[^/]' \| \ > X"$ac_file" : 'X\(//\)$' \| \ > X"$ac_file" : 'X\(/\)' \| \ > . : '\(.\)' 2>/dev/null || > echo X"$ac_file" | > sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; } > /^X\(\/\/\)[^/].*/{ s//\1/; q; } > /^X\(\/\/\)$/{ s//\1/; q; } > /^X\(\/\).*/{ s//\1/; q; } > s/.*/./; q'` > { if $as_mkdir_p; then > mkdir -p "$ac_dir" > else > as_dir="$ac_dir" > as_dirs= > while test ! -d "$as_dir"; do > as_dirs="$as_dir $as_dirs" > as_dir=`(dirname "$as_dir") 2>/dev/null || > $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ > X"$as_dir" : 'X\(//\)[^/]' \| \ > X"$as_dir" : 'X\(//\)$' \| \ > X"$as_dir" : 'X\(/\)' \| \ > . : '\(.\)' 2>/dev/null || > echo X"$as_dir" | > sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; } > /^X\(\/\/\)[^/].*/{ s//\1/; q; } > /^X\(\/\/\)$/{ s//\1/; q; } > /^X\(\/\).*/{ s//\1/; q; } > s/.*/./; q'` > done > test ! -n "$as_dirs" || mkdir $as_dirs > fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5 > echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;} > { (exit 1); exit 1; }; }; } > > rm -f $ac_file > mv $tmp/config.h $ac_file > fi > else > cat $tmp/config.h > rm -f $tmp/config.h > fi > done > _ACEOF > cat >>$CONFIG_STATUS <<\_ACEOF > > # > # CONFIG_COMMANDS section. > # > for ac_file in : $CONFIG_COMMANDS; do test "x$ac_file" = x: && continue > ac_dest=`echo "$ac_file" | sed 's,:.*,,'` > ac_source=`echo "$ac_file" | sed 's,[^:]*:,,'` > ac_dir=`(dirname "$ac_dest") 2>/dev/null || > $as_expr X"$ac_dest" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ > X"$ac_dest" : 'X\(//\)[^/]' \| \ > X"$ac_dest" : 'X\(//\)$' \| \ > X"$ac_dest" : 'X\(/\)' \| \ > . : '\(.\)' 2>/dev/null || > echo X"$ac_dest" | > sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; } > /^X\(\/\/\)[^/].*/{ s//\1/; q; } > /^X\(\/\/\)$/{ s//\1/; q; } > /^X\(\/\).*/{ s//\1/; q; } > s/.*/./; q'` > { if $as_mkdir_p; then > mkdir -p "$ac_dir" > else > as_dir="$ac_dir" > as_dirs= > while test ! -d "$as_dir"; do > as_dirs="$as_dir $as_dirs" > as_dir=`(dirname "$as_dir") 2>/dev/null || > $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ > X"$as_dir" : 'X\(//\)[^/]' \| \ > X"$as_dir" : 'X\(//\)$' \| \ > X"$as_dir" : 'X\(/\)' \| \ > . : '\(.\)' 2>/dev/null || > echo X"$as_dir" | > sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; } > /^X\(\/\/\)[^/].*/{ s//\1/; q; } > /^X\(\/\/\)$/{ s//\1/; q; } > /^X\(\/\).*/{ s//\1/; q; } > s/.*/./; q'` > done > test ! -n "$as_dirs" || mkdir $as_dirs > fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5 > echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;} > { (exit 1); exit 1; }; }; } > > ac_builddir=. > > if test "$ac_dir" != .; then > ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'` > # A "../" for each directory in $ac_dir_suffix. > ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'` > else > ac_dir_suffix= ac_top_builddir= > fi > > case $srcdir in > .) # No --srcdir option. We are building in place. > ac_srcdir=. > if test -z "$ac_top_builddir"; then > ac_top_srcdir=. > else > ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'` > fi ;; > [\\/]* | ?:[\\/]* ) # Absolute path. > ac_srcdir=$srcdir$ac_dir_suffix; > ac_top_srcdir=$srcdir ;; > *) # Relative path. > ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix > ac_top_srcdir=$ac_top_builddir$srcdir ;; > esac > > # Do not use `cd foo && pwd` to compute absolute paths, because > # the directories may not exist. > case `pwd` in > .) ac_abs_builddir="$ac_dir";; > *) > case "$ac_dir" in > .) ac_abs_builddir=`pwd`;; > [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";; > *) ac_abs_builddir=`pwd`/"$ac_dir";; > esac;; > esac > case $ac_abs_builddir in > .) ac_abs_top_builddir=${ac_top_builddir}.;; > *) > case ${ac_top_builddir}. in > .) ac_abs_top_builddir=$ac_abs_builddir;; > [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;; > *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;; > esac;; > esac > case $ac_abs_builddir in > .) ac_abs_srcdir=$ac_srcdir;; > *) > case $ac_srcdir in > .) ac_abs_srcdir=$ac_abs_builddir;; > [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;; > *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;; > esac;; > esac > case $ac_abs_builddir in > .) ac_abs_top_srcdir=$ac_top_srcdir;; > *) > case $ac_top_srcdir in > .) ac_abs_top_srcdir=$ac_abs_builddir;; > [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;; > *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;; > esac;; > esac > > > { echo "$as_me:$LINENO: executing $ac_dest commands" >&5 > echo "$as_me: executing $ac_dest commands" >&6;} > case $ac_dest in > default-1 ) > for entry in $MPID_THREAD_SOURCE_FILES ; do > destfile="src/`echo $entry | sed -e 's/:.*$//'`" > srcfile="`echo $entry | sed -e 's/^.*://'`" > echo "copying $srcfile to $destfile" > rm -f $destfile > cat >$destfile < /* > * WARNING: DO NOT EDIT! This file is a copy of $srcfile. > */ > > END > cat $srcfile >>$destfile > chmod 444 $destfile > done > ;; > esac > done > _ACEOF > > cat >>$CONFIG_STATUS <<\_ACEOF > > { (exit 0); exit 0; } > _ACEOF > chmod +x $CONFIG_STATUS > ac_clean_files=$ac_clean_files_save > > > # configure is writing to config.log, and then calls config.status. > # config.status does its own redirection, appending to config.log. > # Unfortunately, on DOS this fails, as config.log is still kept open > # by configure, so config.status won't be able to write to it; its > # output is simply discarded. So we exec the FD to /dev/null, > # effectively closing config.log, so it can be properly (re)opened and > # appended to by config.status. When coming back to configure, we > # need to make the FD available again. > if test "$no_create" != yes; then > ac_cs_success=: > ac_config_status_args= > test "$silent" = yes && > ac_config_status_args="$ac_config_status_args --quiet" > exec 5>/dev/null > $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false > exec 5>>config.log > # Use ||, not &&, to avoid exiting from the if with $? = 1, which > # would make configure fail if this is the last instruction. > $ac_cs_success || { (exit 1); exit 1; } > fi > > > diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/configure.in bgp-mpich2/src/mpid/dcmf/configure.in 0a1,73 > AC_INIT(configure.in) > > dnl > dnl Set the directory that contains support scripts such as install-sh and > dnl config.guess > dnl > AC_CONFIG_AUX_DIR(../../../confdb) > > dnl > dnl Definitions will be placed in this file rather than in the DEFS variable > dnl > AC_CONFIG_HEADER(include/mpid_config.h) > > echo "RUNNING CONFIGURE FOR DCMF DEVICE" > > dnl > dnl First check that we have a clean build if we are doing a VPATH build > if test "`cd $srcdir && pwd`" != "`pwd`" && \ > test -f $srcdir/config.status ; then > AC_MSG_ERROR([You cannot do a VPATH build if the source directory has been > configured. Run "make distclean" in $srcdir first.]) > fi > > PAC_ARG_CACHING > AC_CACHE_LOAD > PAC_PROG_MAKE > > > ASSERT_LEVEL=2 > AC_ARG_WITH(assert-level, > AS_HELP_STRING([--with-assert-level={0 1 2}],[set build assert-level (default: 2)]), > [ ASSERT_LEVEL=$withval ]) > AC_SUBST(ASSERT_LEVEL) > AC_DEFINE_UNQUOTED([ASSERT_LEVEL], $ASSERT_LEVEL, [Which messager is being used]) > > > # > # bring in the default implementation of the MPID_Thread package > # > MPID_THREAD_SRCDIR="../common/thread" > builtin(include,../common/thread/mpid_thread.m4) > > > AC_SUBST(AR) > AC_SUBST(RANLIB) > AC_SUBST(MPILIBNAME) > AC_SUBST(CC) > AC_SUBST(CFLAGS) > AC_SUBST(CPPFLAGS) > AC_SUBST(CC_SHL) > AC_SUBST(C_LINK_SHL) > AC_SUBST(master_top_srcdir) > AC_SUBST(master_top_builddir) > AC_SUBST(MAKE_DEPEND_C) > AC_SUBST(ENABLE_SHLIB) > AC_SUBST(MKDIR_P) > > INSTALL="/usr/bin/install -c" > INSTALL_PROGRAM="${INSTALL}" > INSTALL_DATA="${INSTALL} -m 644" > AC_SUBST(INSTALL) > AC_SUBST(INSTALL_DATA) > AC_SUBST(INSTALL_PROGRAM) > > > FILE=`cd $srcdir && find -name Makefile.in | perl -pe 's,^\./,,;s/\.in$//'` > AC_OUTPUT( > localdefs > $MPID_THREAD_OUTPUT_FILES > $FILE > ) > > PAC_SUBDIR_CACHE_CLEANUP diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/cross bgp-mpich2/src/mpid/dcmf/cross 0a1,27 > CROSS_F77_SIZEOF_INTEGER=4 > CROSS_F77_SIZEOF_REAL=4 > CROSS_F77_SIZEOF_DOUBLE_PRECISION=8 > CROSS_F90_ADDRESS_KIND=4 > CROSS_F90_OFFSET_KIND=8 > CROSS_SIZEOF_CHAR=1 > CROSS_SIZEOF_SHORT=2 > CROSS_SIZEOF_INT=4 > CROSS_SIZEOF_LONG=4 > CROSS_SIZEOF_LONG_LONG=8 > CROSS_SIZEOF_FLOAT=4 > CROSS_SIZEOF_DOUBLE=8 > CROSS_SIZEOF_LONG_DOUBLE=8 > CROSS_SIZEOF_WCHAR_T=2 > CROSS_SIZEOF_VOID_P=4 > CROSS_SIZEOF_FLOAT_INT=8 > CROSS_SIZEOF_DOUBLE_INT=16 > CROSS_SIZEOF_LONG_INT=8 > CROSS_SIZEOF_SHORT_INT=8 > CROSS_SIZEOF_2_INT=8 > CROSS_SIZEOF_LONG_DOUBLE_INT=16 > CROSS_SIZEOF_LONG_LONG_INT=16 > CROSS_FORTRAN2C_TRUE=1 > CROSS_FORTRAN2C_FALSE=0 > CROSS_BIGENDIAN=true > CROSS_SIZEOF_VOID_GREATER=no > CROSS_MPI_STATUS_SIZE=5 diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/include/.cvsignore bgp-mpich2/src/mpid/dcmf/include/.cvsignore 0a1 > mpid_config.h.in diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/include/mpidimpl.h bgp-mpich2/src/mpid/dcmf/include/mpidimpl.h 0a1,455 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file include/mpidimpl.h > * \brief DCMF API MPID additions to MPI functions and structures > */ > > /* > * (C) 2001 by Argonne National Laboratory. > * See COPYRIGHT in top-level directory. > */ > > #ifndef MPICH_DCMF_MPIDIMPL_H_INCLUDED > #define MPICH_DCMF_MPIDIMPL_H_INCLUDED > > /* **************************************************************** > * Asserts are divided into three levels: > * 1. abort - Always active and always issues assert(0). > * Primarily used for unimplemented code paths. > * 2. assert - Active by default, or when MPID_ASSERT_PROD is defined. > * Meant to flag user errors. > * 3. assert_debug - Active by default. Meant to flag coding > * errors before shipping. > * Only one of MPID_ASSERT_ABORT, MPID_ASSERT_PROD (or nothing) should > * be specified. > * - MPID_ASSERT_ABORT means that the "abort" level is the only level > * of asserts that is active. Other levels are turned off. > * - MPID_ASSERT_PROD means that "abort" and "assert" levels are active. > * "assert_debug" is turned off. > * - Not specifying MPID_ASSERT_ABORT or MPID_ASSERT_PROD means that all > * levels of asserts ("abort", "assert", "assert_debug") are > * active. > * **************************************************************** > */ > #include > #include > > #if ASSERT_LEVEL==0 > #define MPID_abort() assert(0) > #define MPID_assert(x) > #define MPID_assert_debug(x) > #elif ASSERT_LEVEL==1 > #define MPID_abort() assert(0) > #define MPID_assert(x) assert(x) > #define MPID_assert_debug(x) > #else /* ASSERT_LEVEL==2 */ > /** \brief Always exit--usually implies missing functionality */ > #define MPID_abort() assert(0) > /** \brief Tests for likely problems--may not be active in performance code */ > #define MPID_assert(x) assert(x) > /** \brief Tests for rare problems--may not be active in production code */ > #define MPID_assert_debug(x) assert(x) > #endif > > #include "mpiimpl.h" > #include "mpidpre.h" > #include "mpidpost.h" > > /** > * \brief MPI Process descriptor > * > * This structure contains the request queues for message tracking > */ > > typedef struct > { > struct > { > unsigned topology; > unsigned collectives; > } > optimized; > unsigned eager_limit; > unsigned verbose : 8; > unsigned statistics : 8; /**< Flag to show the current level of stats collection */ > unsigned use_interrupts : 1; > /*unsigned unused_flags : 15; */ > unsigned rma_pending; > } MPIDI_Process_t; > extern MPIDI_Process_t MPIDI_Process; > > typedef struct > { > DCMF_Protocol_t send; > DCMF_Protocol_t rzv; > DCMF_Protocol_t get; > DCMF_Protocol_t protocol; > DCMF_Protocol_t control; > DCMF_Protocol_t globalbarrier; > DCMF_Protocol_t globalbcast; > DCMF_Protocol_t globalallreduce; > } MPIDI_Protocol_t; > extern MPIDI_Protocol_t MPIDI_Protocols; > > typedef struct > { > unsigned char numcolors; /* number of colors for bcast/allreduce */ > /* Optimized barrier protocols and usage flags */ > struct > { > DCMF_CollectiveProtocol_t gi; > unsigned char usegi; > DCMF_CollectiveProtocol_t binomial; > unsigned char usebinom; > } barrier; > unsigned char optbarrier; /* do we have an optimized barrier? */ > > /* Optimized local barrier protocols and usage flags (not used directly by MPICH > * but stored in the geometry) */ > struct > { > DCMF_CollectiveProtocol_t lockbox; > unsigned char uselockbox; > DCMF_CollectiveProtocol_t binomial; > unsigned char usebinom; > } localbarrier; > > /* Optimized broadcast protocols and usage flags */ > struct > { > DCMF_CollectiveProtocol_t tree; > unsigned char usetree; > DCMF_CollectiveProtocol_t rectangle; > unsigned char userect; > DCMF_CollectiveProtocol_t binomial; > unsigned char usebinom; > } broadcast; > unsigned char optbroadcast; > > /* Optimized alltoallv protocol and usage flag */ > struct > { > DCMF_CollectiveProtocol_t torus; > unsigned char usetorus; > } alltoallv; > > /* For consistancy, optimized alltoall flag. Uses alltoallv protocol */ > struct > { > unsigned char usetorus; > unsigned char premalloc; > } alltoall; > > struct > { > unsigned char usetorus; > } alltoallw; > > > /* Optimized allgather usage flag */ > struct > { > unsigned char useallreduce; > unsigned char usebcast; > unsigned char usealltoallv; > } allgather; > unsigned char optallgather; > > /* Optimized allgatherv usage flag */ > struct > { > unsigned char useallreduce; > unsigned char usebcast; > unsigned char usealltoallv; > } allgatherv; > unsigned char optallgatherv; > > /* Optimized allreduce protocols and usage flags */ > struct > { > unsigned char reusestorage; > DCMF_CollectiveProtocol_t pipelinedtree; > unsigned char usepipelinedtree; > DCMF_CollectiveProtocol_t tree; > unsigned char usetree; > unsigned char useccmitree; > DCMF_CollectiveProtocol_t rectangle; > unsigned char userect; > DCMF_CollectiveProtocol_t rectanglering; > unsigned char userectring; > DCMF_CollectiveProtocol_t binomial; > unsigned char usebinom; > } allreduce; > unsigned char optallreduce; > > /* Optimized reduce protocols and usage flags */ > struct > { > unsigned char reusestorage; > DCMF_CollectiveProtocol_t tree; > unsigned char usetree; > unsigned char useccmitree; > DCMF_CollectiveProtocol_t rectangle; > unsigned char userect; > DCMF_CollectiveProtocol_t rectanglering; > unsigned char userectring; > DCMF_CollectiveProtocol_t binomial; > unsigned char usebinom; > } reduce; > unsigned char optreduce; > > } MPIDI_CollectiveProtocol_t; > extern MPIDI_CollectiveProtocol_t MPIDI_CollectiveProtocols; > > extern DCMF_Hardware_t mpid_hw; > > /** > * ************************************************************************* > * Low-level request utilities: allocation, release of > * requests, with a holding pen for just-released requests. This is > * code stolen from MPICH, now in mpidi_dcmfts_request.c > * ************************************************************************* > */ > > /** > * ************************************************************************* > * Request queue related utilities (stolen from CH3; in src/impl) > * ************************************************************************* > */ > > /** > * \addtogroup MPID_RECVQ > * \{ > */ > void MPIDI_Recvq_init(); > void MPIDI_Recvq_finalize(); > MPID_Request * MPIDI_Recvq_FU (int s, int t, int c); > MPID_Request * MPIDI_Recvq_FDURSTC (MPID_Request * req, int source, int tag, int context_id); > MPID_Request * MPIDI_Recvq_FDUR (MPID_Request * req); > MPID_Request * MPIDI_Recvq_FDU_or_AEP(int s, int t, int c, int * foundp); > int MPIDI_Recvq_FDPR (MPID_Request * req); > MPID_Request * MPIDI_Recvq_FDP_or_AEU(int s, int t, int c, int * foundp); > void MPIDI_Recvq_DumpQueues(int verbose); > /**\}*/ > > void MPIDI_DCMF_Buffer_copy(const void * const sbuf, > int scount, > MPI_Datatype sdt, > int * smpi_errno, > void * const rbuf, > int rcount, > MPI_Datatype rdt, > MPIDI_msg_sz_t * rsz, > int * rmpi_errno); > > /** > * \addtogroup MPID_PROGRESS > * \{ > */ > void MPID_Progress_start (MPID_Progress_state * state); > void MPID_Progress_end (MPID_Progress_state * state); > int MPID_Progress_wait (MPID_Progress_state * state); > int MPID_Progress_poke (); > int MPID_Progress_test (); > void MPID_Progress_signal(); > /** > * \brief A macro to easily implement advancing until a specific > * condition becomes false. > * > * \param COND This is not a true parameter. It is *specifically* > * designed to be evaluated several times, allowing for the result to > * change. The condition would generally look something like > * "(cb.client == 0)". This would be used as the condition on a while > * loop. > * > * \returns MPI_SUCCESS > * > * This correctly checks the condition before attempting to loop, > * since the call to MPID_Progress_wait() may not return if the event > * is already complete. Any ssytem *not* using this macro *must* use > * a similar check before waiting. > */ > #define MPID_PROGRESS_WAIT_WHILE(COND) \ > ({ \ > if (COND) \ > { \ > MPID_Progress_state dummy; \ > \ > MPID_Progress_start(&dummy); \ > while (COND) \ > MPID_Progress_wait(&dummy); \ > MPID_Progress_end(&dummy); \ > } \ > MPI_SUCCESS; \ > }) > /**\}*/ > > > /** > * \brief Gets significant info regarding the datatype > * Used in mpid_send, mpidi_send. Stolen from CH3 channel implementation. > */ > #define MPIDI_Datatype_get_info(_count, _datatype, \ > _dt_contig_out, _data_sz_out, _dt_ptr, _dt_true_lb) \ > { \ > if (HANDLE_GET_KIND(_datatype) == HANDLE_KIND_BUILTIN) \ > { \ > (_dt_ptr) = NULL; \ > (_dt_contig_out) = TRUE; \ > (_dt_true_lb) = 0; \ > (_data_sz_out) = (_count) * \ > MPID_Datatype_get_basic_size(_datatype); \ > } \ > else \ > { \ > MPID_Datatype_get_ptr((_datatype), (_dt_ptr)); \ > (_dt_contig_out) = (_dt_ptr)->is_contig; \ > (_dt_true_lb) = (_dt_ptr)->true_lb; \ > (_data_sz_out) = (_count) * (_dt_ptr)->size; \ > } \ > } > > /** > * \addtogroup MPID_REQUEST > * \{ > */ > > MPID_Request * MPID_Request_create (); > MPID_Request * MPID_SendRequest_create (); > void MPID_Request_destroy (MPID_Request *req); > void MPID_Request_release (MPID_Request *req); > > /* completion count */ > void MPID_Request_complete (MPID_Request *req); > void MPID_Request_set_completed (MPID_Request *req); > > #define MPID_Request_decrement_cc(_req, _inuse) { *(_inuse) = --(*(_req)->cc_ptr) ; } > #define MPID_Request_increment_cc(_req) { (*(_req)->cc_ptr)++; } > > #define MPID_Request_add_ref(_req) \ > { \ > MPID_assert(HANDLE_GET_MPI_KIND((_req)->handle) == MPID_REQUEST); \ > MPIU_Object_add_ref(_req); \ > } > > #define MPID_Request_setCA(_req, _ca) { (_req)->dcmf.ca = (_ca); } > #define MPID_Request_setPeerRank(_req,_r) { (_req)->dcmf.peerrank = (_r); } > #define MPID_Request_setPeerRequest(_req,_r) { (_req)->dcmf.msginfo.msginfo.req = (_r); } > #define MPID_Request_setType(_req,_t) { (_req)->dcmf.msginfo.msginfo.type = (_t); } > #define MPID_Request_setSelf(_req,_t) { (_req)->dcmf.msginfo.msginfo.isSelf = (_t); } > #define MPID_Request_setSync(_req,_t) { (_req)->dcmf.msginfo.msginfo.isSync = (_t); } > #define MPID_Request_setRzv(_req,_t) { (_req)->dcmf.msginfo.msginfo.isRzv = (_t); } > #define MPID_Request_setMatch(_req,_tag,_rank,_ctxtid) \ > { \ > (_req)->dcmf.msginfo.msginfo.MPItag=(_tag); \ > (_req)->dcmf.msginfo.msginfo.MPIrank=(_rank); \ > (_req)->dcmf.msginfo.msginfo.MPIctxt=(_ctxtid); \ > } > > #define MPID_Request_getCA(_req) ( (_req)->dcmf.ca ) > #define MPID_Request_getType(_req) ( (_req)->dcmf.msginfo.msginfo.type ) > #define MPID_Request_isSelf(_req) ( (_req)->dcmf.msginfo.msginfo.isSelf ) > #define MPID_Request_isSync(_req) ( (_req)->dcmf.msginfo.msginfo.isSync ) > #define MPID_Request_isRzv(_req) ( (_req)->dcmf.msginfo.msginfo.isRzv ) > #define MPID_Request_getMatchTag(_req) ( (_req)->dcmf.msginfo.msginfo.MPItag ) > #define MPID_Request_getMatchRank(_req) ( (_req)->dcmf.msginfo.msginfo.MPIrank ) > #define MPID_Request_getMatchCtxt(_req) ( (_req)->dcmf.msginfo.msginfo.MPIctxt ) > #define MPID_Request_getPeerRank(_req) ( (_req)->dcmf.peerrank ) > #define MPID_Request_getPeerRequest(_req) ( (_req)->dcmf.msginfo.msginfo.req ) > /**\}*/ > > > /** > * \defgroup MPID_CALLBACKS MPID callbacks for DCMF communication > * > * These calls are used to manage message asynchronous start and completion > */ > /** > * \addtogroup MPID_CALLBACKS > * \{ > */ > DCMF_Request_t * MPIDI_BG2S_RecvCB(void * clientdata, > const MPIDI_DCMF_MsgInfo * msginfo, > unsigned count, > unsigned senderrank, > const unsigned sndlen, > unsigned * rcvlen, > char ** rcvbuf, > DCMF_Callback_t * const cb_info); > > void MPIDI_BG2S_RecvShortCB(void * clientdata, > const MPIDI_DCMF_MsgInfo * msginfo, > unsigned count, > unsigned senderrank, > const char * sndbuf, > unsigned sndlen); > > void MPIDI_BG2S_RecvRzvCB(void * clientdata, > const MPIDI_DCMF_RzvEnvelope * rzv_envelope, > unsigned count, > unsigned senderrank, > const char * sndbuf, > unsigned sndlen); > > void MPIDI_DCMF_SendDoneCB (MPID_Request * sreq); > void MPIDI_DCMF_RecvDoneCB (MPID_Request * rreq); > void MPIDI_DCMF_RecvRzvDoneCB (MPID_Request * rreq); > void MPIDI_DCMF_StartMsg (MPID_Request * sreq); > /** \} */ > > > /** \brief Acknowledge an MPI_Ssend() */ > int MPIDI_DCMF_postSyncAck (MPID_Request * req); > /** \brief Cancel an MPI_Send(). */ > int MPIDI_DCMF_postCancelReq(MPID_Request * req); > /** \brief This is the general PT2PT control message call-back */ > void MPIDI_BG2S_ControlCB (void * clientdata, const DCMF_Control_t * p, unsigned peer); > /** > * \brief Mark a request as cancel-pending > * \param[in] _req The request to cancel > * \param[out] _flag The previous state > */ > #define MPIDI_DCMF_Request_cancel_pending(_req, _flag) \ > { \ > *(_flag) = (_req)->dcmf.cancel_pending; \ > (_req)->dcmf.cancel_pending = TRUE; \ > } > > > /** \brief Helper function when sending to self */ > int MPIDI_Isend_self(const void * buf, > int count, > MPI_Datatype datatype, > int rank, > int tag, > MPID_Comm * comm, > int context_offset, > int type, > MPID_Request ** request); > > /** \brief Helper function to complete a rendevous transfer */ > void MPIDI_DCMF_RendezvousTransfer (MPID_Request * rreq); > > void MPID_Dump_stacks (); > > > void MPIDI_Comm_create (MPID_Comm *comm); > void MPIDI_Comm_destroy (MPID_Comm *comm); > void MPIDI_Env_setup (); > > void MPIDI_Topo_Comm_create (MPID_Comm *comm); > void MPIDI_Topo_Comm_destroy (MPID_Comm *comm); > int MPID_Dims_create (int nnodes, int ndims, int *dims); > > void MPIDI_Coll_Comm_create (MPID_Comm *comm); > void MPIDI_Coll_Comm_destroy (MPID_Comm *comm); > void MPIDI_Coll_register (void); > > #endif diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/include/mpido_coll.h bgp-mpich2/src/mpid/dcmf/include/mpido_coll.h 0a1,175 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file include/mpido_coll.h > * \brief Function prototypes for the optimized collective routines > */ > > #ifndef MPICH_DCMF_MPIDO_COLL_H_INCLUDED > #define MPICH_DCMF_MPIDO_COLL_H_INCLUDED > > #include "mpidimpl.h" > > #define NOTTREEOP 1 > > typedef struct { > int send_contig; > int recv_contig; > int recv_continuous; > } MPIDO_Coll_config; > > /* Helpers */ > unsigned *MPIDI_Comm_worldranks_init(MPID_Comm *comm_ptr); > > int MPIDI_ConvertMPItoDCMF(MPI_Op op, > DCMF_Op *dcmf_op, > MPI_Datatype datatype, > DCMF_Dt *dcmf_dt); > > > /* Alltoall */ > int MPIDO_Alltoall(void *sendbuf, > int sendcount, > MPI_Datatype sendtype, > void *recvbuf, > int recvcount, > MPI_Datatype recvtype, > MPID_Comm *comm_ptr); > > > /* Alltoallv */ > int MPIDO_Alltoallv(void *sendbuf, > int *sendcounts, > int *senddispls, > MPI_Datatype sendtype, > void *recvbuf, > int *recvcounts, > int *recvdispls, > MPI_Datatype recvtype, > MPID_Comm *comm_ptr); > > /* Alltoallw */ > int MPIDO_Alltoallw(void *sendbuf, > int *sendcounts, > int *senddispls, > MPI_Datatype *sendtypes, > void *recvbuf, > int *recvcounts, > int *recvdispls, > MPI_Datatype *recvtypes, > MPID_Comm *comm_ptr); > /* barrier */ > int MPIDO_Barrier(MPID_Comm *comm_ptr); > > > /* bcast */ > int MPIDO_Bcast(void * buffer, > int count, > MPI_Datatype datatype, > int root, > MPID_Comm * comm_ptr); > > /* allreduce */ > int MPIDO_Allreduce(void * sendbuf, > void * recvbuf, > int count, > MPI_Datatype datatype, > MPI_Op op, > MPID_Comm * comm_ptr); > > /* reduce */ > int MPIDO_Reduce(void * sendbuf, > void * recvbuf, > int count, > MPI_Datatype datatype, > MPI_Op op, > int root, > MPID_Comm * comm_ptr); > > /* allgather */ > int MPIDO_Allgather(void *sendbuf, > int sendcount, > MPI_Datatype sendtype, > void *recvbuf, > int recvcount, > MPI_Datatype recvtype, > MPID_Comm * comm_ptr); > > /* allgather */ > int MPIDO_Allgatherv(void *sendbuf, > int sendcount, > MPI_Datatype sendtype, > void *recvbuf, > int *recvcounts, > int *displs, > MPI_Datatype recvtype, > MPID_Comm * comm_ptr); > > /* these aren't optimized, but are included for completeness */ > int MPIDO_Gather(void *sendbuf, > int sendcount, > MPI_Datatype sendtype, > void *recvbuf, > int recvcount, > MPI_Datatype recvtype, > int root, > MPID_Comm * comm_ptr); > > int MPIDO_Gatherv(void *sendbuf, > int sendcount, > MPI_Datatype sendtype, > void *recvbuf, > int *recvcounts, > int *displs, > MPI_Datatype recvtype, > int root, > MPID_Comm * comm_ptr); > > int MPIDO_Scatter(void *sendbuf, > int sendcount, > MPI_Datatype sendtype, > void *recvbuf, > int recvcount, > MPI_Datatype recvtype, > int root, > MPID_Comm * comm_ptr); > > int MPIDO_Scatterv(void *sendbuf, > int *sendcounts, > int *displs, > MPI_Datatype sendtype, > void *recvbuf, > int recvcount, > MPI_Datatype recvtype, > int root, > MPID_Comm * comm_ptr); > > int MPIDO_Reduce_scatter(void *sendbuf, > void *recvbuf, > int *recvcounts, > MPI_Datatype datatype, > MPI_Op op, > MPID_Comm * comm_ptr); > int MPIDO_Scan(void *sendbuf, > void *recvbuf, > int count, > MPI_Datatype datatype, > MPI_Op op, > MPID_Comm * comm_ptr); > > int MPIDO_Exscan(void *sendbuf, > void *recvbuf, > int count, > MPI_Datatype datatype, > MPI_Op op, > MPID_Comm * comm_ptr); > > > > #endif diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/include/mpidpost.h bgp-mpich2/src/mpid/dcmf/include/mpidpost.h 0a1,27 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file include/mpidpost.h > * \brief The trailing device header > * > * This file is included after the rest of the headers > * (mpidimpl.h, mpidpre.h, and mpiimpl.h) > */ > /* > * (C) 2001 by Argonne National Laboratory. > * See COPYRIGHT in top-level directory. > */ > > #ifndef MPICH_MPIDPOST_H_INCLUDED > #define MPICH_MPIDPOST_H_INCLUDED > > #include "mpid_datatype.h" > #include "mpid_statistics.h" > > #endif diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/include/mpidpre.h bgp-mpich2/src/mpid/dcmf/include/mpidpre.h 0a1,397 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file include/mpidpre.h > * \brief The leading device header > * > * This file is included at the start of the other headers > * (mpidimpl.h, mpidpost.h, and mpiimpl.h). It generally contains > * additions to MPI objects. > */ > /* > * (C) 2001 by Argonne National Laboratory. > * See COPYRIGHT in top-level directory. > */ > > > #ifndef MPICH_MPIDPRE_H_INCLUDED > #define MPICH_MPIDPRE_H_INCLUDED > > /* include message layer stuff */ > #include > #include > > #include "mpid_dataloop.h" > > /** > * \brief Declare hook(s) for Datatype create/destroy > * > * multiple hooks could be defined, for example: > * #define ...hook(a) { func1(a); func2(a); ... } > */ > #ifdef MPID_Dev_datatype_create_hook > #error MPID_Dev_datatype_create_hook already defined somewhere else! > #else /* !MPID_Dev_datatype_create_hook */ > #define MPID_Dev_datatype_create_hook(a) > #endif /* !MPID_Dev_datatype_create_hook */ > > #ifdef MPID_Dev_datatype_destroy_hook > #error MPID_Dev_datatype_destroy_hook already defined somewhere else! > #else /* !MPID_Dev_datatype_destroy_hook */ > #define MPID_Dev_datatype_destroy_hook(a) {\ > extern void MPIDU_dtc_free(MPID_Datatype *);\ > MPIDU_dtc_free(a); \ > } > #endif /* !MPID_Dev_datatype_destroy_hook */ > > /** > * ****************************************************************** > * \brief Mutexes for interrupt driven mode > * ****************************************************************** > */ > #ifdef MPID_CS_ENTER > #error "MPID_CS_ENTER is already defined" > #endif > #define MPID_DEFINES_MPID_CS 1 > #define MPID_CS_INITIALIZE() \ > { \ > /* Create thread local storage for nest count that MPICH uses */ \ > MPID_Thread_tls_create(NULL, &MPIR_ThreadInfo.thread_storage, NULL); \ > } > #define MPID_CS_FINALIZE() \ > { \ > /* Destroy thread local storage created during MPID_CS_INITIALIZE */\ > MPID_Thread_tls_destroy(&MPIR_ThreadInfo.thread_storage, NULL); \ > } > #if (MPICH_THREAD_LEVEL != MPI_THREAD_MULTIPLE) > #define MPID_CS_ENTER() {} > #define MPID_CS_EXIT() {} > #define MPID_CS_CYCLE() {} > #else > #define MPID_CS_ENTER() DCMF_CriticalSection_enter(0); > #define MPID_CS_EXIT() DCMF_CriticalSection_exit(0); > #define MPID_CS_CYCLE() DCMF_CriticalSection_cycle(0); > #endif > > > typedef struct MPIDI_VC > { > int handle; > volatile int ref_count; > int lpid; > } > MPIDI_VC; > > typedef struct MPIDI_VCRT * MPID_VCRT; > typedef struct MPIDI_VC * MPID_VCR; > #define MPID_GPID_Get(comm_ptr, rank, gpid) \ > { \ > gpid[0] = 0; \ > gpid[1] = comm_ptr->vcr[rank]->lpid; \ > } > > /** \brief Our progress engine does not require state */ > #define MPID_PROGRESS_STATE_DECL > > /** > * ****************************************************************** > * \brief MPI Onesided operation device declarations (!!! not used) > * Is here only because mpiimpl.h needs it. > * ****************************************************************** > */ > typedef struct MPIDI_RMA_ops { > struct MPIDI_RMA_ops *next; /* pointer to next element in list */ > int type; /* MPIDI_RMA_PUT, MPID_REQUEST_GET, > MPIDI_RMA_ACCUMULATE, MPIDI_RMA_LOCK */ > void *origin_addr; > int origin_count; > MPI_Datatype origin_datatype; > int target_rank; > MPI_Aint target_disp; > int target_count; > MPI_Datatype target_datatype; > MPI_Op op; /* for accumulate */ > int lock_type; /* for win_lock */ > } MPIDI_RMA_ops; > > /* to send derived datatype across in RMA ops */ > typedef struct MPIDI_RMA_dtype_info > { > int is_contig; > int n_contig_blocks; > int size; > MPI_Aint extent; > int dataloop_size; > void *dataloop; > int dataloop_depth; > int eltype; > MPI_Aint ub; > MPI_Aint lb; > MPI_Aint true_ub; > MPI_Aint true_lb; > int has_sticky_ub; > int has_sticky_lb; > int unused0; > int unused1; > } > MPIDI_RMA_dtype_info; > > > /** > * \brief This defines the type of message being sent/received > * mpid_startall() invokes the correct start based on the type of the request > */ > typedef enum > { > MPIDI_DCMF_REQUEST_TYPE_RECV=0, > MPIDI_DCMF_REQUEST_TYPE_SEND, > MPIDI_DCMF_REQUEST_TYPE_RSEND, > MPIDI_DCMF_REQUEST_TYPE_BSEND, > MPIDI_DCMF_REQUEST_TYPE_SSEND, > MPIDI_DCMF_REQUEST_TYPE_SSEND_ACKNOWLEDGE, > MPIDI_DCMF_REQUEST_TYPE_CANCEL_REQUEST, > MPIDI_DCMF_REQUEST_TYPE_CANCEL_ACKNOWLEDGE, > MPIDI_DCMF_REQUEST_TYPE_CANCEL_NOT_ACKNOWLEDGE, > MPIDI_DCMF_REQUEST_TYPE_RENDEZVOUS_ACKNOWLEDGE, > MPIDI_DCMF_REQUEST_TYPE_PLACEHOLDER > } > MPIDI_DCMF_REQUEST_TYPE; > > > typedef enum > { > MPIDI_DCMF_INITIALIZED=0, > MPIDI_DCMF_SEND_COMPLETE, > MPIDI_DCMF_ACKNOWLEGED, > MPIDI_DCMF_REQUEST_DONE_CANCELLED > } > MPIDI_DCMF_REQUEST_STATE; > > > /** > * \brief MPIDI_Message_match contains enough information to match an > * MPI message. > */ > typedef struct MPIDI_Message_match > { > int tag; /**< match tag */ > int rank; /**< match rank */ > int context_id; /**< match context */ > } > MPIDI_Message_match; > > > /** > * \brief Message Info (has to be exactly 128 bits long) and associated data types > * \note sizeof(MPIDI_DCMF_MsgInfo) == 16 > */ > typedef struct > { > void * req; /**< peer's request pointer */ > unsigned MPItag; /**< match tag */ > unsigned MPIrank; /**< match rank */ > unsigned MPIctxt:16; /**< match context */ > > unsigned type:8; /**< message type */ > unsigned isSelf:1; /**< message sent to self */ > unsigned isSync:1; /**< set for sync sends */ > > unsigned isRzv:1; /**< use pt2pt rendezvous */ > > /* These are not currently in use : */ > unsigned isResend:1; /**< Unused: this message is a re-send */ > unsigned isSending:1; /**< Unused: message is currently being sent */ > unsigned extra_flags:3; /**< Unused */ > } MPIDI_DCMF_MsgInfo_t; > typedef union MPIDI_DCMF_MsgInfo > { > DCQuad quad[1]; > MPIDI_DCMF_MsgInfo_t msginfo; > } > MPIDI_DCMF_MsgInfo; > > /** \brief Rendezvous information for flow-control of unexpected messages. */ > typedef struct MPIDI_DCMF_RzvInfo > { > void * sndbuf; > unsigned sndlen; > } > MPIDI_DCMF_RzvInfo; > > /** \brief Request completion actions */ > typedef enum > { > MPIDI_DCMF_CA_ERROR = 0, /* Should never see this */ > MPIDI_DCMF_CA_COMPLETE = 1, /* The request is now complete */ > MPIDI_DCMF_CA_UNPACK_UEBUF_AND_COMPLETE, /* Unpack uebuf, then complete */ > MPIDI_DCMF_CA_UNPACK_UEBUF_AND_COMPLETE_NOFREE, /* Unpack uebuf, then complete. do not free uebuf */ > MPIDI_DCMF_CA_DISCARD_UEBUF_AND_COMPLETE, /* Discard uebuf, then complete */ > } > MPIDI_DCMF_CA; > > > /** \brief Full Rendezvous msg info to be set as two quads of unexpected data. */ > typedef union > { > struct > { > MPIDI_DCMF_MsgInfo msginfo; > MPIDI_DCMF_RzvInfo rzvinfo; > }; > DCQuad quad[2]; > } MPIDI_DCMF_RzvEnvelope; > > /** \brief This defines the portion of MPID_Request that is specific to the DCMF Device */ > struct MPIDI_DCMF_Request > { > MPIDI_DCMF_MsgInfo msginfo; /**< Match info and type/flags */ > unsigned peerrank; /**< The other guy's rank */ > > MPIDI_DCMF_CA ca; /**< Completion action */ > > char * userbuf; /**< User buffer */ > unsigned userbufcount; /**< Userbuf data count */ > char * uebuf; /**< Unexpected buffer */ > unsigned uebuflen; /**< Length (bytes) of uebuf */ > > MPI_Datatype datatype; /**< Data type of message */ > struct MPID_Datatype * datatype_ptr; /**< Info about the datatype */ > > int cancel_pending; /**< Cancel State */ > MPIDI_DCMF_REQUEST_STATE state; /**< The tranfser state */ > > DCMF_Request_t msg; /**< The message layer request */ > > MPIDI_DCMF_RzvInfo rzvinfo; /**< Rendezvous msg information */ > > struct MPID_Request * next; /**< Link to next req. in queue */ > }; > /** \brief This defines the portion of MPID_Request that is specific to the DCMF Device */ > #define MPID_DEV_REQUEST_DECL struct MPIDI_DCMF_Request dcmf; > > > /** \brief needed by the (stolen) CH3 implementation of dcmf_buffer.c */ > typedef unsigned MPIDI_msg_sz_t; > > /** \brief This defines the portion of MPID_Comm that is specific to the DCMF Device */ > struct MPIDI_DCMF_Comm > { > DCMF_Geometry_t geometry; /**< Geometry component for collectives */ > DCMF_CollectiveRequest_t barrier; /**< Barrier request for collectives */ > unsigned *worldranks; /**< rank list to be used by collectives */ > unsigned *sndlen; /**< lazy alloc alltoall vars */ > unsigned *rcvlen; > unsigned *sdispls; > unsigned *rdispls; > unsigned *sndcounters; > unsigned *rcvcounters; > unsigned char allreducetree; /**< Comm specific tree flags */ > unsigned char allreducepipelinedtree; /**< Comm specific tree flags */ > unsigned char reducetree; > unsigned char allreduceccmitree; > unsigned char reduceccmitree; > unsigned char bcasttree; > unsigned char alltoalls; > }; > /** \brief This defines the portion of MPID_Comm that is specific to the DCMF Device */ > #define MPID_DEV_COMM_DECL struct MPIDI_DCMF_Comm dcmf; > > > #ifdef HAVE_DEV_COMM_HOOK > #error "Build error - HAVE_DEV_COMM_HOOK defined at least twice!" > #else > #define HAVE_DEV_COMM_HOOK > #define MPID_Dev_comm_create_hook(a) MPIDI_Comm_create(a) > #define MPID_Dev_comm_destroy_hook(a) MPIDI_Comm_destroy(a) > #endif > > > struct MPID_Comm; > > /** > * \brief Collective information related to a window > * > * This structure is used to share information about a local window with > * all nodes in the window communicator. Part of that information includes > * statistics about RMA operations during access/exposure epochs. > * > * The structure is allocated as an array sized for the window communicator. > * Each entry in the array corresponds directly to the node of the same rank. > */ > struct MPID_Win_coll_info { > void *base_addr; /**< Node's exposure window base address */ > int disp_unit; /**< Node's exposure window displacement units */ > MPI_Win win_handle; /**< Node's exposure window handle (local to target node) */ > int rma_sends; /**< Count of RMA operations that target node */ > }; > > /* assert sizeof(struct MPID_Win_coll_info) == 16 */ > > /** > * \brief Structure of BG extensions to MPID_Win structure > */ > struct MPID_Dev_win_decl { > struct MPID_Win_coll_info *coll_info; /**< allocated array of collective info */ > struct MPID_Comm *comm_ptr; /**< saved pointer to window communicator */ > volatile int lock_granted; /**< window lock */ > unsigned long _lock_queue[4]; /**< opaque structure used for lock wait queue */ > unsigned long _unlk_queue[4]; /**< opaque structure used for unlock wait queue */ > volatile int my_sync_begin; /**< counter of POST messages received */ > volatile int my_sync_done; /**< counter of COMPLETE messages received */ > volatile int my_rma_recvs; /**< counter of RMA operations received */ > volatile int my_rma_pends; /**< counter of RMA operations queued to send */ > volatile int my_get_pends; /**< counter of GET operations queued */ > DCMF_Consistency my_cstcy; /**< default consistency for window */ > volatile int epoch_type; /**< current epoch type */ > volatile int epoch_size; /**< current epoch size (or target for LOCK) */ > int epoch_assert; /**< MPI_MODE_* bits asserted at epoch start */ > int epoch_rma_ok; /**< flag indicating an exposure epoch is in affect */ > }; > > /** > * \brief Code-snippet macro to add BG extensions to MPID_Win object structure > */ > #define MPID_DEV_WIN_DECL struct MPID_Dev_win_decl _dev; > > > /** > * @defgroup MPID_EPOTYPE MPID One-sided Epoch Types > *@{ > */ > #define MPID_EPOTYPE_NONE 0 /**< No epoch in affect */ > #define MPID_EPOTYPE_LOCK 1 /**< MPI_Win_lock access epoch */ > #define MPID_EPOTYPE_START 2 /**< MPI_Win_start access epoch */ > #define MPID_EPOTYPE_POST 3 /**< MPI_Win_post exposure epoch */ > #define MPID_EPOTYPE_POSTSTART 4 /**< MPI_Win_post+MPI_Win_start access/exposure epoch */ > #define MPID_EPOTYPE_FENCE 5 /**< MPI_Win_fence access/exposure epoch */ > /**@}*/ > > /** > * @defgroup MPID_MSGTYPE MPID One-sided Message Types > *@{ > */ > #define MPID_MSGTYPE_NONE 0 /**< Not a valid message */ > #define MPID_MSGTYPE_LOCK 1 /**< lock window */ > #define MPID_MSGTYPE_UNLOCK 2 /**< (try) unlock window */ > #define MPID_MSGTYPE_POST 3 /**< begin POST epoch */ > #define MPID_MSGTYPE_START 4 /**< (not used) */ > #define MPID_MSGTYPE_COMPLETE 5 /**< end a START epoch */ > #define MPID_MSGTYPE_WAIT 6 /**< (not used) */ > #define MPID_MSGTYPE_FENCE 7 /**< (not used) */ > #define MPID_MSGTYPE_UNFENCE 8 /**< (not used) */ > #define MPID_MSGTYPE_PUT 9 /**< PUT RMA operation */ > #define MPID_MSGTYPE_GET 10 /**< GET RMA operation */ > #define MPID_MSGTYPE_ACC 11 /**< ACCUMULATE RMA operation */ > #define MPID_MSGTYPE_DT_MAP 12 /**< Datatype map payload */ > #define MPID_MSGTYPE_DT_IOV 13 /**< Datatype iov payload */ > #define MPID_MSGTYPE_LOCKACK 14 /**< lock acknowledge */ > #define MPID_MSGTYPE_UNLOCKACK 15 /**< unlock acknowledge, with status */ > /**@}*/ > > #endif /* !MPICH_MPIDPRE_H_INCLUDED */ diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/include/mpid_statistics.h bgp-mpich2/src/mpid/dcmf/include/mpid_statistics.h 0a1,100 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file include/mpid_statistics.h > * \brief Functions useful for instrumenting code and collecting performance statistics > */ > > #ifndef MPID_STATISTICS_H > #define MPID_STATISTICS_H > > /** > * \defgroup STATISTICS Performance statistics > * \brief These items handle the processing of performance counters > */ > > /** > * \ingroup STATISTICS > * \brief Turn on the statistics code (or not) > */ > #define USE_STATISTICS > /* #undef USE_STATISTICS */ > > > > #ifdef USE_STATISTICS > > /** > * \ingroup STATISTICS > * \brief Storage for statistical collection > */ > typedef struct { > size_t s0; /**< The running sum of the input^0 (AKA add 1 every time) */ > size_t s1; /**< The running sum of the input^1 */ > size_t s2; /**< The running sum of the input^2 */ > size_t max; /**< The largest input seen so far */ > } stat_time; > > /** > * \ingroup STATISTICS > * \brief local storage for the individual counters > */ > typedef struct { > struct { > stat_time posted_search; /**< The counter for the posted queue */ > stat_time unexpected_search; /**< The counter for the unexpected queue */ > } recvq; /**< Counters related to the recvq system */ > } MPIDI_Statistics_t; > > /** > * \ingroup STATISTICS > * \brief Add another event with the stats system > * \param[in,out] s The current counter structure > * \param[in] m The time it took the event to complete > * \returns m > */ > #define MPIDI_Statistics_time(s, m) \ > ({ \ > s.s0 += 1; \ > s.s1 += m; \ > s.s2 += m*m; \ > if (s.max < m) \ > s.max = m; \ > m; \ > }) > #else > #define MPIDI_Statistics_time(s, m) m > #endif > > #ifdef USE_STATISTICS > /** > * \ingroup STATISTICS > * \brief External storage for the individual counters > */ > extern MPIDI_Statistics_t MPIDI_Statistics; > #endif > > > /** > * \ingroup STATISTICS > * \brief Initialize the individual counters > * > * Basically, this simply zeroes out the entire statistics structure. > */ > void MPIDI_Statistics_init(); > > /** > * \ingroup STATISTICS > * \brief Complete and optionally print the results from the stats collection > * > * The results are only printed when the MPIDI_Process.statistics flag is set. > */ > void MPIDI_Statistics_finalize(); > > #endif diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/include/mpix.h bgp-mpich2/src/mpid/dcmf/include/mpix.h 0a1,160 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file include/mpix.h > * \brief Blue Gene extensions to the MPI Spec > * > * These functions generally use MPI functions and internal APIs to > * expose extra information relating to the specific system on which > * the job is running. This may allow certain hardware specific > * optimizations to be made. > */ > > #ifndef MPIX_H > #define MPIX_H > > #if defined(__cplusplus) > extern "C" { > #endif > > > #include > > /** > * \defgroup MPIX IBM Blue Gene extensions to MPICH2 > * \brief These utilities can be used to better understand & manage > * the BG hardware currently in use. > */ > > /** > * \ingroup MPIX > * \brief Create a Cartesian communicator that exactly matches the partition > * > * \param[out] cart_comm The new Cartesian communicator > * > * \return MPI_SUCCESS or MPI_ERR_TOPOLOGY > * > * This is a collective operation on MPI_COMM_WORLD, and will only > * run successfully on a full partition job (no -np) > * > * The communicator is created to match the size of each dimension, > * the physical coords on each node, and the torus/messh link > * status. Because of MPICH2 dimension ordering, the associated > * arrays (i.e. coords, sizes, and periods) are in [t, z, y, x,] > * order so that the rank in cart_comm matches the rank in > * MPI_COMM_WORLD > */ > int MPIX_Cart_comm_create (MPI_Comm *cart_comm); > > /** > * \ingroup MPIX > * \brief Create a communicator such that all nodes in the same > * communicator are served by the same I/O node > * > * \param[out] pset_comm The new communicator > * > * \return MPI_SUCCESS > * > * This is a collective operation on MPI_COMM_WORLD > */ > int MPIX_Pset_same_comm_create (MPI_Comm *pset_comm); > > /** > * \ingroup MPIX > * \brief Create a communicator such that all nodes in the same > * communicator are served by a different I/O node > * > * \param[out] pset_comm The new communicator > * > * \return MPI_SUCCESS > * > * This is a collective operation on MPI_COMM_WORLD > */ > int MPIX_Pset_diff_comm_create (MPI_Comm *pset_comm); > > > /** > * \ingroup MPIX > * \brief Return the mapped rank based on the physical X, Y, Z, and > * T coords > * > * \param[in] x The node's X coord > * \param[in] y The node's Y coord > * \param[in] z The node's Z coord > * \param[in] t The node's T coord > * > * \return Mapped rank > */ > unsigned MPIX_torus2rank (unsigned x, > unsigned y, > unsigned z, > unsigned t); > > /** > * \ingroup MPIX > * \brief Return the physical X, Y, Z, and T coords based on the > * mapped rank > * > * \param[in] rank The node's mapped rank > * \param[out] x The node's X coord > * \param[out] y The node's Y coord > * \param[out] z The node's Z coord > * \param[out] t The node's T coord > */ > void MPIX_rank2torus (unsigned rank, > unsigned *x, > unsigned *y, > unsigned *z, > unsigned *t); > > > /** > * \ingroup MPIX > * \brief Return the communicator rank based on the physical X, Y, > * Z, and T coords > * > * \param[in] comm The communicator to use > * \param[in] x The node's X coord > * \param[in] y The node's Y coord > * \param[in] z The node's Z coord > * \param[in] t The node's T coord > * > * \return Communicator rank > */ > unsigned MPIX_Comm_torus2rank (MPI_Comm comm, > unsigned x, > unsigned y, > unsigned z, > unsigned t); > > /** > * \ingroup MPIX > * \brief Return the physical X, Y, Z, and T coords based on the > * communicator rank > * > * \param[in] comm The communicator to use > * \param[in] rank The node's communicator rank > * \param[out] x The node's X coord > * \param[out] y The node's Y coord > * \param[out] z The node's Z coord > * \param[out] t The node's T coord > */ > void MPIX_Comm_rank2torus (MPI_Comm comm, > unsigned rank, > unsigned *x, > unsigned *y, > unsigned *z, > unsigned *t); > > > #if defined(__cplusplus) > } > #endif > > #endif diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/localdefs.in bgp-mpich2/src/mpid/dcmf/localdefs.in 0a1,2 > #!/bin/sh > echo "******** Running DCMF localdefs *****" diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/Makefile.sm bgp-mpich2/src/mpid/dcmf/Makefile.sm 0a1,11 > install_INCLUDE = ${srcdir}/include/mpix.h > SUBDIRS = src . > > distclean-local: > -rm -f include/mpidi_bg_conf.h > > maintainerclean-local: > -rm -f include/mpidi_bg_conf.h.in > > echomaxprocname: > @echo 131070 diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/mpich2prereq bgp-mpich2/src/mpid/dcmf/mpich2prereq 0a1,65 > #! /bin/sh > # > # Provide information to the top level configure about the capabilities of the dcmf device. > # > # Currently, this is restricted to allowing the channels to assert > # support for MPI_THREAD_MULTIPLE > # > # Get the channel from the device_args, and invoke any channel prereq > echo "Executing mpich2prereq in $devicedir with $device_args" > if test -z "$device_args" ; then > device_args=none > fi > > if test "$device_args" = "BGP" ; then > MPID_MAX_PROCESSOR_NAME=128 > MPID_NO_LONG_LONG=no > MPID_NO_LONG_DOUBLE=no > MPID_NO_SPAWN=yes > MPID_NO_RMA=no > MPID_MAX_THREAD_LEVEL=MPI_THREAD_MULTIPLE > MPID_NO_PM=yes > MPID_NO_PMI=yes > fi > > #Possible values > # MPID_MAX_THREAD_LEVEL - thread level supported by device. > # if unset, is MPI_THREAD_FUNNELED > # MPID_NO_LONG_LONG - if yes, the device does not support the > # long long integer type > # MPID_NO_LONG_DOUBLE - if yes, the device does not support the > # long double type > # MPID_PM_NAMESERVER - if set, provides the name of the nameserver > # that the process manager supports. > # This name server will be used if the > # default name server is selected. > # MPID_NO_PM - If yes, the device does not require any > # PM implementation. > # MPID_NO_PMI - If yes, the device does not require any > # PMI implementation. > # EXTRA_STATUS_DECL - Any extra declarations that the device > # needs added to the definition of MPI_Status. > # MPID_MAX_PROCESSOR_NAME - The maximum number of character in a processor > # name. If not set, 128 will be used. > # PMI_REQUIRES_READABLE_TOKENS - if yes, define the C-preprocessor > # value USE_HUMAN_READABLE_TOKENS, which is > # used in src/include/mpimem.h to define token > # separators used in src/util/mem/argstr.c > # PM_REQUIRES_PMI - if set, provides the name of the PMI > # interface implementation. If not set, > # the "simple" PMI implementation is used. > # A process manager that needs a particular > # process manager should check that this is > # not set to an incompatible value. > # MPID_NO_SPAWN - if yes, the device does not support the > # dynamic process routines (spawn, connect > # attach, join, plus port and publish > # routines). The major effect of this > # is to let the test codes know that > # spawn is not implemented. > # MPID_NO_RMA - if yes, the device does not support the > # MPI RMA routines (MPI_Win_create and > # MPI_Put etc.). The major effect of this > # is to let the test codes know that > # RMA is not implemented. > # diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/setup_device bgp-mpich2/src/mpid/dcmf/setup_device 0a1,39 > echo "****** RUNNING SETUP_DEVICE FOR THE DCMF DEVICE ******" > echo "* CC=${CC}" > echo "* configure args=${ac_configure_args}" > echo "* MSGLAYER_LIB=${MSGLAYER_LIB}" > echo "* device_args=${device_args}" > echo "******************************************************" > > # > # NOTE: This file is sourced from the top-level configure script with the > # current working directory set to the top-level build directory. > # > master_top_builddir="`pwd`" > > # > # Variables of interest... > # > # $master_top_srcdir - top-level source directory > # $device_name - ought to be bgl > # $device_args - contains name of channel select plus an channel args > # $with_device - device name and arguments > # $ac_configure_args - all arguments passed to configure > # > > pathlist="" > pathlist="$pathlist src/mpid/${device_name}/include" > pathlist="$pathlist src/mpid/common/datatype" > pathlist="$pathlist src/mpid/common/locks" > > for path in $pathlist ; do > CPPFLAGS="${CPPFLAGS} -I${master_top_builddir}/${path}" > CPPFLAGS="${CPPFLAGS} -I${master_top_srcdir}/${path}" > done > > CPPFLAGS="${CPPFLAGS} ${MSGLAYER_INCLUDE}" > LIBS="${LIBS} ${MSGLAYER_LIB}" > > echo "******************************************************" > echo "CPPFLAGS=${CPPFLAGS}" > echo "******************************************************" diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/coll/allgather/Makefile.sm bgp-mpich2/src/mpid/dcmf/src/coll/allgather/Makefile.sm 0a1,3 > SUBDIRS= . > INCLUDES = -I${master_top_srcdir}/src/include -I${top_builddir}/src/include > lib${MPILIBNAME}_a_SOURCES = mpido_allgather.c diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/coll/allgather/mpido_allgather.c bgp-mpich2/src/mpid/dcmf/src/coll/allgather/mpido_allgather.c 0a1,335 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file src/coll/allgather/mpido_allgather.c > * \brief ??? > */ > > #include "mpido_coll.h" > > #pragma weak PMPIDO_Allgather = MPIDO_Allgather > > > /* ****************************************************************** */ > /** > * \brief Use (tree) MPIDO_Allreduce() to do a fast Allgather operation > * > * \note This function requires that: > * - The send/recv data types are contiguous > * - Tree allreduce is availible (for max performance) > * - The datatype parameters needed added to the function signature > */ > /* ****************************************************************** */ > int MPIDO_Allgather_Allreduce(void *sendbuf, > int sendcount, > MPI_Datatype sendtype, > void *recvbuf, > int recvcount, > MPI_Datatype recvtype, > MPID_Comm * comm_ptr, > MPI_Aint send_true_lb, > MPI_Aint recv_true_lb, > size_t send_size, > size_t recv_size) > > { > char *startbuf = NULL; > char *destbuf = NULL; > startbuf = (char *) recvbuf + recv_true_lb; > destbuf = startbuf + comm_ptr->rank * send_size; > > memset(startbuf, 0, comm_ptr->rank * send_size); > memset(destbuf + send_size, 0, recv_size - (comm_ptr->rank + 1) * send_size); > if (sendbuf != MPI_IN_PLACE) > { > char *outputbuf = (char *) sendbuf + send_true_lb; > memcpy(destbuf, outputbuf, send_size); > } > > return MPIDO_Allreduce(MPI_IN_PLACE, > startbuf, > recv_size/4, > MPI_INT, > MPI_BOR, > comm_ptr); > } > > > /* ****************************************************************** */ > /** > * \brief Use (tree/rect) MPIDO_Bcast() to do a fast Allgather operation > * > * \note This function requires one of these (for max performance): > * - Tree broadcast > */ > /* ****************************************************************** */ > int MPIDO_Allgather_Bcast(void *sendbuf, > int sendcount, > MPI_Datatype sendtype, > void *recvbuf, > int recvcount, > MPI_Datatype recvtype, > MPID_Comm * comm_ptr) > { > int i; > MPI_Aint extent; > MPID_Datatype_get_extent_macro(recvtype, extent); > if (sendbuf != MPI_IN_PLACE) > { > void *destbuf = recvbuf + comm_ptr->rank * recvcount * extent; > MPIR_Localcopy(sendbuf, > sendcount, > sendtype, > destbuf, > recvcount, > recvtype); > } > > for (i = 0; i < comm_ptr->local_size; i++) > { > void *destbuf = recvbuf + i * recvcount * extent; > MPIDO_Bcast(destbuf, > recvcount, > recvtype, > i, > comm_ptr); > } > > return MPI_SUCCESS; > } > > /* ****************************************************************** */ > /** > * \brief Use (tree/rect) MPIDO_Alltoall() to do a fast Allgather operation > * > * \note This function requires that: > * - The send/recv data types are contiguous > * - DMA alltoallv is availible (for max performance) > * - The datatype parameters needed added to the function signature > */ > /* ****************************************************************** */ > int MPIDO_Allgather_Alltoall(void *sendbuf, > int sendcount, > MPI_Datatype sendtype, > void *recvbuf, > int recvcount, > MPI_Datatype recvtype, > MPID_Comm * comm_ptr, > MPI_Aint send_true_lb, > MPI_Aint recv_true_lb, > size_t send_size, > size_t recv_size) > { > int i; > void *a2a_sendbuf = NULL; > char *destbuf=NULL; > char *startbuf=NULL; > > int a2a_sendcounts[comm_ptr->local_size]; > int a2a_senddispls[comm_ptr->local_size]; > int a2a_recvcounts[comm_ptr->local_size]; > int a2a_recvdispls[comm_ptr->local_size]; > > for (i = 0; i < comm_ptr->local_size; ++i) > { > a2a_sendcounts[i] = send_size; > a2a_senddispls[i] = 0; > a2a_recvcounts[i] = recvcount; > a2a_recvdispls[i] = recvcount * i; > } > if (sendbuf != MPI_IN_PLACE) > { > a2a_sendbuf = sendbuf + send_true_lb; > } > else > { > startbuf = (char *) recvbuf + recv_true_lb; > destbuf = startbuf + comm_ptr->rank * send_size; > a2a_sendbuf = destbuf; > a2a_sendcounts[comm_ptr->rank] = 0; > > a2a_recvcounts[comm_ptr->rank] = 0; > } > > return MPIDO_Alltoallv(a2a_sendbuf, > a2a_sendcounts, > a2a_senddispls, > MPI_CHAR, > recvbuf, > a2a_recvcounts, > a2a_recvdispls, > recvtype, > comm_ptr); > } > > > int > MPIDO_Allgather(void *sendbuf, > int sendcount, > MPI_Datatype sendtype, > void *recvbuf, > int recvcount, > MPI_Datatype recvtype, > MPID_Comm * comm_ptr) > { > /* ********************************* > * Check the nature of the buffers > * ********************************* > */ > > MPIDO_Coll_config config = {1,1,1}; > MPID_Datatype *dt_null = NULL; > MPI_Aint send_true_lb = 0; > MPI_Aint recv_true_lb = 0; > size_t send_size = 0; > size_t recv_size = 0; > > > int result = MPI_SUCCESS; > > /* no optimized allgather, punt to mpich */ > if(MPIDI_CollectiveProtocols.optallgather && > (MPIDI_CollectiveProtocols.allgather.useallreduce || > MPIDI_CollectiveProtocols.allgather.usebcast || > MPIDI_CollectiveProtocols.allgather.usealltoallv) == 0) > { > return MPIR_Allgather(sendbuf, > sendcount, > sendtype, > recvbuf, > recvcount, > recvtype, > comm_ptr); > } > > > MPIDI_Datatype_get_info(recvcount, > recvtype, > config.recv_contig, > recv_size, > dt_null, > recv_true_lb); > send_size = recv_size; > recv_size *= comm_ptr->local_size; > if (sendbuf != MPI_IN_PLACE) > MPIDI_Datatype_get_info(sendcount, > sendtype, > config.send_contig, > send_size, > dt_null, > send_true_lb); > > /* verify everyone's datatype contiguity */ > MPIDO_Allreduce(MPI_IN_PLACE, > &config, > 3, > MPI_INT, > MPI_BAND, > comm_ptr); > > /* determine which protocol to use */ > /* 1) Tree allreduce > * a) Need tree allreduce for this communicator, otherwise it is silly > * b) User must be ok with allgather via allreduce > * c) Datatypes must be continguous > * d) Count must be a multiple of 4 since tree doesn't support > * chars right now > */ > char treereduce = comm_ptr->dcmf.allreducetree && > MPIDI_CollectiveProtocols.allgather.useallreduce && > config.recv_contig && config.send_contig && > config.recv_continuous && recv_size % 4 ==0; > > /* 2) Tree bcast > * a) Need tree bcast for this communicator, otherwise performance sucks > * b) User must be ok with allgather via bcast > */ > char treebcast = comm_ptr->dcmf.bcasttree && > MPIDI_CollectiveProtocols.allgather.usebcast; > > /* 3) Alltoall > * a) Need torus alltoall for this communicator > * b) User must be ok with allgather via alltoall > * c) Need contiguous datatypes > */ > char usealltoall = comm_ptr->dcmf.alltoalls && > MPIDI_CollectiveProtocols.allgather.usealltoallv && > config.recv_contig && config.send_contig; > > > /* Benchmark data shows bcast is faster for larger messages, so if > * both bcast and reduce are available, use bcast >32768 > */ > if(treereduce && treebcast && recvcount > 32768) > result = MPIDO_Allgather_Bcast(sendbuf, > sendcount, > sendtype, > recvbuf, > recvcount, > recvtype, > comm_ptr); > else if(treereduce && treebcast && recvcount <= 32768) > result = MPIDO_Allgather_Allreduce(sendbuf, > sendcount, > sendtype, > recvbuf, > recvcount, > recvtype, > comm_ptr, > send_true_lb, > recv_true_lb, > send_size, > recv_size); > /* we only can use allreduce, so use it regardless of size */ > else if(treereduce) > result = MPIDO_Allgather_Allreduce(sendbuf, > sendcount, > sendtype, > recvbuf, > recvcount, > recvtype, > comm_ptr, > send_true_lb, > recv_true_lb, > send_size, > recv_size); > /* or, we can only use bcast, so use it regardless of size */ > else if(treebcast) > result = MPIDO_Allgather_Bcast(sendbuf, > sendcount, > sendtype, > recvbuf, > recvcount, > recvtype, > comm_ptr); > /* no tree protocols (probably not comm_world) so use alltoall */ > else if(usealltoall) > result = MPIDO_Allgather_Alltoall(sendbuf, > sendcount, > sendtype, > recvbuf, > recvcount, > recvtype, > comm_ptr, > send_true_lb, > recv_true_lb, > send_size, > recv_size); > /* don't even have alltoall, so use mpich */ > else > result = MPIR_Allgather(sendbuf, > sendcount, > sendtype, > recvbuf, > recvcount, > recvtype, > comm_ptr); > > return result; > } diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/coll/allgatherv/Makefile.sm bgp-mpich2/src/mpid/dcmf/src/coll/allgatherv/Makefile.sm 0a1,3 > SUBDIRS= . > INCLUDES = -I${master_top_srcdir}/src/include -I${top_builddir}/src/include > lib${MPILIBNAME}_a_SOURCES = mpido_allgatherv.c diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/coll/allgatherv/mpido_allgatherv.c bgp-mpich2/src/mpid/dcmf/src/coll/allgatherv/mpido_allgatherv.c 0a1,455 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file src/coll/allgatherv/mpido_allgatherv.c > * \brief ??? > */ > > #include "mpido_coll.h" > > #pragma weak PMPIDO_Allgatherv = MPIDO_Allgatherv > > > /* ****************************************************************** */ > /** > * \brief Use (tree) MPIDO_Allreduce() to do a fast Allgatherv operation > * > * \note This function requires that: > * - The send/recv data types are contiguous > * - The recv buffer is continuous > * - Tree allreduce is availible (for max performance) > */ > /* ****************************************************************** */ > int MPIDO_Allgatherv_Allreduce(void *sendbuf, > int sendcount, > MPI_Datatype sendtype, > void *recvbuf, > int *recvcounts, > int *displs, > MPI_Datatype recvtype, > MPID_Comm * comm_ptr, > MPI_Aint send_true_lb, > MPI_Aint recv_true_lb, > size_t send_size, > size_t recv_size, > int buffer_sum) > { > int start; > int length; > char *startbuf = NULL; > char *destbuf = NULL; > > startbuf = (char *) recvbuf + recv_true_lb; > destbuf = startbuf + displs[comm_ptr->rank] * recv_size; > > start = 0; > length = displs[comm_ptr->rank] * recv_size; > memset(startbuf + start, 0, length); > > start = (displs[comm_ptr->rank] + > recvcounts[comm_ptr->rank]) * recv_size; > length = buffer_sum - (displs[comm_ptr->rank] + > recvcounts[comm_ptr->rank]) * recv_size; > memset(startbuf + start, 0, length); > > if (sendbuf != MPI_IN_PLACE) > { > char *outputbuf = (char *) sendbuf + send_true_lb; > memcpy(destbuf, outputbuf, send_size); > } > > //if (0==comm_ptr->rank) puts("allreduce allgatherv"); > return MPIDO_Allreduce(MPI_IN_PLACE, > startbuf, > buffer_sum/4, > MPI_INT, > MPI_BOR, > comm_ptr); > } > > /* ****************************************************************** */ > /** > * \brief Use (tree/rect) MPIDO_Bcast() to do a fast Allgatherv operation > * > * \note This function requires one of these (for max performance): > * - Tree broadcast > * - Rect broadcast > * ? Binomial broadcast > */ > /* ****************************************************************** */ > int MPIDO_Allgatherv_Bcast(void *sendbuf, > int sendcount, > MPI_Datatype sendtype, > void *recvbuf, > int *recvcounts, > int *displs, > MPI_Datatype recvtype, > MPID_Comm * comm_ptr) > { > int i; > MPI_Aint extent; > MPID_Datatype_get_extent_macro(recvtype, extent); > if (sendbuf != MPI_IN_PLACE) > { > void *destbuffer = recvbuf + displs[comm_ptr->rank] * extent; > MPIR_Localcopy(sendbuf, > sendcount, > sendtype, > destbuffer, > recvcounts[comm_ptr->rank], > recvtype); > } > > for (i = 0; i < comm_ptr->local_size; i++) > { > void *destbuffer = recvbuf + displs[i] * extent; > MPIDO_Bcast(destbuffer, > recvcounts[i], > recvtype, > i, > comm_ptr); > } > //if (0==comm_ptr->rank) puts("bcast allgatherv"); > return MPI_SUCCESS; > } > > /* ****************************************************************** */ > /** > * \brief Use (tree/rect) MPIDO_Alltoall() to do a fast Allgatherv operation > * > * \note This function requires that: > * - The send/recv data types are contiguous > * - DMA alltoallv is availible (for max performance) > */ > /* ****************************************************************** */ > int MPIDO_Allgatherv_Alltoall(void *sendbuf, > int sendcount, > MPI_Datatype sendtype, > void *recvbuf, > int *recvcounts, > int *displs, > MPI_Datatype recvtype, > MPID_Comm * comm_ptr, > MPI_Aint send_true_lb, > MPI_Aint recv_true_lb, > size_t recv_size) > { > size_t send_size; > char *startbuf; > char *destbuf; > int i; > int aresult; > int my_recvcounts = -1; > void *a2a_sendbuf = NULL; > int a2a_sendcounts[comm_ptr->local_size]; > int a2a_senddispls[comm_ptr->local_size]; > > send_size = recvcounts[comm_ptr->rank] * recv_size; > for (i = 0; i < comm_ptr->local_size; ++i) > { > a2a_sendcounts[i] = send_size; > a2a_senddispls[i] = 0; > } > if (sendbuf != MPI_IN_PLACE) > { > a2a_sendbuf = sendbuf + send_true_lb; > } > else > { > startbuf = (char *) recvbuf + recv_true_lb; > destbuf = startbuf + displs[comm_ptr->rank] * recv_size; > a2a_sendbuf = destbuf; > a2a_sendcounts[comm_ptr->rank] = 0; > my_recvcounts = recvcounts[comm_ptr->rank]; > recvcounts[comm_ptr->rank] = 0; > } > > //if (0==comm_ptr->rank) puts("all2all allgatherv"); > aresult = MPIDO_Alltoallv(a2a_sendbuf, > a2a_sendcounts, > a2a_senddispls, > MPI_CHAR, > recvbuf, > recvcounts, > displs, > recvtype, > comm_ptr); > if (sendbuf == MPI_IN_PLACE) > recvcounts[comm_ptr->rank] = my_recvcounts; > > return aresult; > } > > > > int > MPIDO_Allgatherv(void *sendbuf, > int sendcount, > MPI_Datatype sendtype, > void *recvbuf, > int *recvcounts, > int *displs, > MPI_Datatype recvtype, > MPID_Comm * comm_ptr) > { > /* ********************************* > * Check the nature of the buffers > * ********************************* > */ > > MPID_Datatype *dt_null = NULL; > MPI_Aint send_true_lb = 0; > MPI_Aint recv_true_lb = 0; > size_t send_size = 0; > size_t recv_size = 0; > MPIDO_Coll_config config = {1,1,1}; > > int result = MPI_SUCCESS; > if(MPIDI_CollectiveProtocols.optallgatherv && > (MPIDI_CollectiveProtocols.allgatherv.useallreduce || > MPIDI_CollectiveProtocols.allgatherv.usebcast || > MPIDI_CollectiveProtocols.allgatherv.usealltoallv) == 0) > { > return MPIR_Allgatherv(sendbuf, > sendcount, > sendtype, > recvbuf, > recvcounts, > displs, > recvtype, > comm_ptr); > } > > MPIDI_Datatype_get_info(1, > recvtype, > config.recv_contig, > recv_size, > dt_null, > recv_true_lb); > > > if (sendbuf != MPI_IN_PLACE) > MPIDI_Datatype_get_info(sendcount, > sendtype, > config.send_contig, > send_size, > dt_null, > send_true_lb); > > int buffer_sum = 0; > { > int i = 0; > if (0 != displs[0]) > config.recv_continuous = 0; > for (i = 1; i < comm_ptr->local_size; ++i) > { > buffer_sum += recvcounts[i - 1]; > if (buffer_sum != displs[i]) > config.recv_continuous = 0; > if (!config.recv_continuous) > break; > } > buffer_sum += recvcounts[comm_ptr->local_size - 1]; > } > buffer_sum *= recv_size; > > MPIDO_Allreduce(MPI_IN_PLACE, > &config, > 3, > MPI_INT, > MPI_BAND, > comm_ptr); > > /* determine which protocol to use */ > /* 1) Tree allreduce > * a) Need tree allreduce for this communicator > * b) User must be ok with allgatherv via allreduce > * c) Datatypes must be continguous > * d) Count must be a multiple of 4 since tree doesn't support > * chars right now > */ > int treereduce = comm_ptr->dcmf.allreducetree && > MPIDI_CollectiveProtocols.allgatherv.useallreduce && > config.recv_contig && config.send_contig && > config.recv_continuous && buffer_sum % 4 ==0; > /* 2) Tree bcast > * a) Need tree bcast for this communicator > * b) User must be ok with allgatherv via bcast > */ > int treebcast = comm_ptr->dcmf.bcasttree && > MPIDI_CollectiveProtocols.allgatherv.usebcast; > > /* 3) Alltoall > * a) Need torus alltoall for this communicator > * b) User must be ok with allgatherv via alltoall > * c) Need contiguous datatypes > */ > int usealltoall = comm_ptr->dcmf.alltoalls && > MPIDI_CollectiveProtocols.allgatherv.usealltoallv && > config.recv_contig && config.send_contig; > > #warning assume same cutoff for allgather > if(treereduce && treebcast && sendcount > 65536) > { > // if(comm_ptr->rank ==0 )fprintf(stderr,"sendcount: %d, calling bcast\n", sendcount); > result = MPIDO_Allgatherv_Bcast(sendbuf, > sendcount, > sendtype, > recvbuf, > recvcounts, > displs, > recvtype, > comm_ptr); > } > else if(treereduce && treebcast && sendcount <= 65536) > { > // if(comm_ptr->rank ==0 )fprintf(stderr,"sendcount: %d, calling allreduce\n", sendcount); > result = MPIDO_Allgatherv_Allreduce(sendbuf, > sendcount, > sendtype, > recvbuf, > recvcounts, > displs, > recvtype, > comm_ptr, > send_true_lb, > recv_true_lb, > send_size, > recv_size, > buffer_sum); > } > else if(treereduce) > { > // if(comm_ptr->rank ==0 )fprintf(stderr,"sendcount: %d, only tree allreduce\n", sendcount); > > result = MPIDO_Allgatherv_Allreduce(sendbuf, > sendcount, > sendtype, > recvbuf, > recvcounts, > displs, > recvtype, > comm_ptr, > send_true_lb, > recv_true_lb, > send_size, > recv_size, > buffer_sum); > } > else if(treebcast) > { > // if(comm_ptr->rank ==0 )fprintf(stderr,"sendcount: %d, only tree bcast\n", sendcount); > result = MPIDO_Allgatherv_Bcast(sendbuf, > sendcount, > sendtype, > recvbuf, > recvcounts, > displs, > recvtype, > comm_ptr); > } > else if(usealltoall) > result = MPIDO_Allgatherv_Alltoall(sendbuf, > sendcount, > sendtype, > recvbuf, > recvcounts, > displs, > recvtype, > comm_ptr, > send_true_lb, > recv_true_lb, > recv_size); > else > return MPIR_Allgatherv(sendbuf, > sendcount, > sendtype, > recvbuf, > recvcounts, > displs, > recvtype, > comm_ptr); > return result; > } > > #if 0 > > > > /* not worth doing on the torus */ > if (MPIDI_CollectiveProtocols.allgatherv.useallreduce && > comm_ptr->dcmf.allreducetree && > config.recv_contig && > config.send_contig && > config.recv_continuous && > buffer_sum % 4 == 0) > { > //if (0==comm_ptr->rank) puts("allreduce allgatherv"); > result = MPIDO_Allgatherv_Allreduce(sendbuf, > sendcount, > sendtype, > recvbuf, > recvcounts, > displs, > recvtype, > comm_ptr, > send_true_lb, > recv_true_lb, > send_size, > recv_size, > buffer_sum); > } > /* again, too slow if we only have a rectangle bcast */ > else if (MPIDI_CollectiveProtocols.allgatherv.usebcast && > comm_ptr->dcmf.bcasttree) > { > //if (0==comm_ptr->rank) puts("bcast allgatherv"); > result = MPIDO_Allgatherv_Bcast(sendbuf, > sendcount, > sendtype, > recvbuf, > recvcounts, > displs, > recvtype, > comm_ptr); > } > else if (MPIDI_CollectiveProtocols.allgatherv.usealltoallv && > comm_ptr->dcmf.alltoalls && > config.recv_contig && > config.send_contig) > { > //if (0==comm_ptr->rank) puts("all2all allgatherv"); > result = MPIDO_Allgatherv_Alltoall(sendbuf, > sendcount, > sendtype, > recvbuf, > recvcounts, > displs, > recvtype, > comm_ptr, > send_true_lb, > recv_true_lb, > recv_size); > } > else > { > //if (0==comm_ptr->rank) puts("mpich2 allgatherv"); > return MPIR_Allgatherv(sendbuf, > sendcount, > sendtype, > recvbuf, > recvcounts, > displs, > recvtype, > comm_ptr); > } > > return result; > } > #endif diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/coll/allreduce/Makefile.sm bgp-mpich2/src/mpid/dcmf/src/coll/allreduce/Makefile.sm 0a1,3 > SUBDIRS= . > INCLUDES = -I${master_top_srcdir}/src/include -I${top_builddir}/src/include > lib${MPILIBNAME}_a_SOURCES = mpido_allreduce.c diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/coll/allreduce/mpido_allreduce.c bgp-mpich2/src/mpid/dcmf/src/coll/allreduce/mpido_allreduce.c 0a1,352 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > > /** > * \file src/coll/allreduce/mpido_allreduce.c > * \brief ??? > */ > > #include "mpido_coll.h" > > #pragma weak PMPIDO_Allreduce = MPIDO_Allreduce > > /** > * ************************************************************************** > * \brief "Done" callback for collective allreduce message. > * ************************************************************************** > */ > > > static void cb_done (void *clientdata) > { > volatile unsigned *work_left = (unsigned *) clientdata; > *work_left = 0; > MPID_Progress_signal(); > > return; > > } > > static int tree_global_allreduce(void * sendbuf, > void * recvbuf, > int count, > DCMF_Dt dcmf_dt, > DCMF_Op dcmf_op, > DCMF_Geometry_t * geometry) > { > int rc; > DCMF_CollectiveRequest_t request; > volatile unsigned active = 1; > DCMF_Callback_t callback = { cb_done, (void *) &active }; > int root = -1; > rc = DCMF_GlobalAllreduce(&MPIDI_Protocols.globalallreduce, > (DCMF_Request_t *)&request, > callback, > DCMF_MATCH_CONSISTENCY, > root, > sendbuf, > recvbuf, > count, > dcmf_dt, > dcmf_op); > MPID_PROGRESS_WAIT_WHILE(active); > > return rc; > } > > static int tree_pipelined_allreduce(void * sendbuf, > void * recvbuf, > int count, > DCMF_Dt dcmf_dt, > DCMF_Op dcmf_op, > DCMF_Geometry_t * geometry) > { > int rc; > DCMF_CollectiveRequest_t request; > volatile unsigned active = 1; > DCMF_Callback_t callback = { cb_done, (void *) &active }; > rc = DCMF_Allreduce(&MPIDI_CollectiveProtocols.allreduce.pipelinedtree, > &request, > callback, > DCMF_MATCH_CONSISTENCY, > geometry, > sendbuf, > recvbuf, > count, > dcmf_dt, > dcmf_op); > MPID_PROGRESS_WAIT_WHILE(active); > > return rc; > } > > static int tree_allreduce(void * sendbuf, > void * recvbuf, > int count, > DCMF_Dt dcmf_dt, > DCMF_Op dcmf_op, > DCMF_Geometry_t * geometry) > { > int rc; > DCMF_CollectiveRequest_t request; > volatile unsigned active = 1; > DCMF_Callback_t callback = { cb_done, (void *) &active }; > rc = DCMF_Allreduce(&MPIDI_CollectiveProtocols.allreduce.tree, > &request, > callback, > DCMF_MATCH_CONSISTENCY, > geometry, > sendbuf, > recvbuf, > count, > dcmf_dt, > dcmf_op); > MPID_PROGRESS_WAIT_WHILE(active); > > return rc; > } > > > static int binom_allreduce(void * sendbuf, > void * recvbuf, > int count, > DCMF_Dt dcmf_dt, > DCMF_Op dcmf_op, > DCMF_Geometry_t * geometry) > { > int rc; > DCMF_CollectiveRequest_t request; > volatile unsigned active = 1; > DCMF_Callback_t callback = { cb_done, (void *) &active }; > > > rc = DCMF_Allreduce(&MPIDI_CollectiveProtocols.allreduce.binomial, > &request, > callback, > DCMF_MATCH_CONSISTENCY, > geometry, > sendbuf, > recvbuf, > count, > dcmf_dt, > dcmf_op); > > > MPID_PROGRESS_WAIT_WHILE(active); > return rc; > } > > static int rect_allreduce(void * sendbuf, > void * recvbuf, > int count, > DCMF_Dt dcmf_dt, > DCMF_Op dcmf_op, > DCMF_Geometry_t * geometry) > { > int rc; > DCMF_CollectiveRequest_t request; > volatile unsigned active = 1; > DCMF_Callback_t callback = { cb_done, (void *) &active }; > > rc = DCMF_Allreduce(&MPIDI_CollectiveProtocols.allreduce.rectangle, > &request, > callback, > DCMF_MATCH_CONSISTENCY, > geometry, > sendbuf, > recvbuf, > count, > dcmf_dt, > dcmf_op); > > MPID_PROGRESS_WAIT_WHILE(active); > return rc; > } > > > > static int rectring_allreduce(void * sendbuf, > void * recvbuf, > int count, > DCMF_Dt dcmf_dt, > DCMF_Op dcmf_op, > DCMF_Geometry_t * geometry) > { > int rc; > DCMF_CollectiveRequest_t request; > volatile unsigned active = 1; > DCMF_Callback_t callback = { cb_done, (void *) &active }; > > rc = DCMF_Allreduce(&MPIDI_CollectiveProtocols.allreduce.rectanglering, > &request, > callback, > DCMF_MATCH_CONSISTENCY, > geometry, > sendbuf, > recvbuf, > count, > dcmf_dt, > dcmf_op); > > MPID_PROGRESS_WAIT_WHILE(active); > return rc; > } > > > > int MPIDO_Allreduce( > void * sendbuf, > void * recvbuf, > int count, > MPI_Datatype datatype, > MPI_Op op, > MPID_Comm * comm_ptr) > { > int dt_contig, dt_extent, rc; > unsigned treeavail, rectavail, binomavail, rectringavail; > > MPID_Datatype *dt_ptr; > MPI_Aint dt_true_lb; > > > DCMF_Dt dcmf_dt = DCMF_UNDEFINED_DT; > DCMF_Op dcmf_op = DCMF_UNDEFINED_OP; > > > if(count == 0) > return MPI_SUCCESS; > treeavail = comm_ptr->dcmf.allreducetree | > comm_ptr->dcmf.allreduceccmitree | > comm_ptr->dcmf.allreducepipelinedtree; > > rc = MPIDI_ConvertMPItoDCMF(op, &dcmf_op, datatype, &dcmf_dt); > > extern int DCMF_TREE_SMP_SHORTCUT; > > if(rc == 0 && treeavail && comm_ptr->local_size > 2) > { > if(sendbuf == MPI_IN_PLACE) > sendbuf = recvbuf; > if(DCMF_TREE_SMP_SHORTCUT && comm_ptr->dcmf.allreducetree) > rc = tree_global_allreduce(sendbuf, > recvbuf, > count, > dcmf_dt, > dcmf_op, > &comm_ptr->dcmf.geometry); > else if (comm_ptr->dcmf.allreduceccmitree) > rc = tree_allreduce(sendbuf, > recvbuf, > count, > dcmf_dt, > dcmf_op, > &comm_ptr->dcmf.geometry); > else if (comm_ptr->dcmf.allreducepipelinedtree) > rc = tree_pipelined_allreduce(sendbuf, > recvbuf, > count, > dcmf_dt, > dcmf_op, > &comm_ptr->dcmf.geometry); > return rc; > } > > > /* quick exit conditions */ > if(comm_ptr->comm_kind != MPID_INTRACOMM) > return MPIR_Allreduce(sendbuf, recvbuf, count, datatype, op, comm_ptr); > > /* check geometry for possibilities */ > rectavail = MPIDI_CollectiveProtocols.allreduce.userect && > DCMF_Geometry_analyze(&comm_ptr->dcmf.geometry, > &MPIDI_CollectiveProtocols.allreduce.rectangle); > > rectringavail = MPIDI_CollectiveProtocols.allreduce.userectring && > DCMF_Geometry_analyze(&comm_ptr->dcmf.geometry, > &MPIDI_CollectiveProtocols.allreduce.rectanglering); > > binomavail = MPIDI_CollectiveProtocols.allreduce.usebinom && > DCMF_Geometry_analyze(&comm_ptr->dcmf.geometry, > &MPIDI_CollectiveProtocols.allreduce.binomial); > > > > // assert(comm_ptr->comm_kind != MPID_INTRACOMM); > > MPIDI_Datatype_get_info(count, > datatype, > dt_contig, > dt_extent, > dt_ptr, > dt_true_lb); > > > /* return conditions */ > if( > // unsupported datatype or op > rc == -1 || > // no optimized topologies for this geometry > (!rectavail && !binomavail && !rectringavail) || > // return to mpich for 1 processor reduce > (comm_ptr -> local_size <=2)) > { > return MPIR_Allreduce(sendbuf, recvbuf, count, datatype, op, comm_ptr); > } > > #warning need benchmark data at this point > /* at this point, decide which network/algorithm we are using based on > * benchmark data, the op, the type, etc, etc > * until then just pick rectangle then binomial based on availability*/ > unsigned usingbinom=1 && binomavail; > unsigned usingrect=1 && rectavail; > unsigned usingrectring=1 && rectringavail; > > > if(sendbuf != MPI_IN_PLACE) > { > // int err = > // MPIR_Localcopy(sendbuf, count, datatype, recvbuf, count, datatype); > // if (err) return err; > } > else > sendbuf = recvbuf; > > if(usingrect) > { > // fprintf(stderr,"rect allreduce, count: %d, dt: %d, op: %d, send: 0x%x, recv: 0x%x\n", count, dcmf_dt, dcmf_op, sendbuf, recvbuf); > rc = rect_allreduce(sendbuf, > recvbuf, > count, > dcmf_dt, > dcmf_op, > &comm_ptr->dcmf.geometry); > } > else if(usingbinom) > { > // fprintf(stderr,"binom allreduce, count: %d, dt: %d, op: %d, send: 0x%x, recv: 0x%x\n", count, dcmf_dt, dcmf_op, sendbuf, recvbuf); > rc = binom_allreduce(sendbuf, > recvbuf, > count, > dcmf_dt, > dcmf_op, > &comm_ptr->dcmf.geometry); > } > else if(usingrectring) > { > // fprintf(stderr,"rectring allreduce, count: %d, dt: %d, op: %d, send: 0x%x, recv: 0x%x\n", count, dcmf_dt, dcmf_op, sendbuf, recvbuf); > rc = rectring_allreduce(sendbuf, > recvbuf, > count, > dcmf_dt, > dcmf_op, > &comm_ptr->dcmf.geometry); > } > > return rc; > } diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/coll/alltoall/Makefile.sm bgp-mpich2/src/mpid/dcmf/src/coll/alltoall/Makefile.sm 0a1,3 > SUBDIRS= . > INCLUDES = -I${master_top_srcdir}/src/include -I${top_builddir}/src/include > lib${MPILIBNAME}_a_SOURCES = mpido_alltoall.c diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/coll/alltoall/mpido_alltoall.c bgp-mpich2/src/mpid/dcmf/src/coll/alltoall/mpido_alltoall.c 0a1,164 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file src/coll/alltoall/mpido_alltoall.c > * \brief ??? > */ > > #include "mpido_coll.h" > > #pragma weak PMPIDO_Alltoall = MPIDO_Alltoall > > /** > * ************************************************************************** > * \brief "Done" callback for collective alltoall message. > * ************************************************************************** > */ > > static void > cb_done(void *clientdata) > { > volatile unsigned *work_left = (unsigned *) clientdata; > *work_left = 0; > MPID_Progress_signal(); > > return; > } > > > static int torus_alltoall(char *sendbuf, > unsigned *sndlen, > unsigned *sdispls, > char *recvbuf, > unsigned *rcvlen, > unsigned *rdispls, > unsigned *sndcounters, > unsigned *rcvcounters, > DCMF_Geometry_t *geometry) > { > int rc; > DCMF_CollectiveRequest_t request; > volatile unsigned active = 1; > DCMF_Callback_t callback = { cb_done, (void *) &active }; > // fprintf(stderr,"torus alltoall\n"); > /* uses the alltoallv protocol */ > rc = DCMF_Alltoallv(&MPIDI_CollectiveProtocols.alltoallv.torus, > &request, > callback, > DCMF_MATCH_CONSISTENCY, > geometry, > sendbuf, > sndlen, > sdispls, > recvbuf, > rcvlen, > rdispls, > sndcounters, > rcvcounters); > > MPID_PROGRESS_WAIT_WHILE(active); > return rc; > } > > > int > MPIDO_Alltoall(void *sendbuf, > int sendcount, > MPI_Datatype sendtype, > void *recvbuf, > int recvcount, > MPI_Datatype recvtype, > MPID_Comm *comm_ptr) > { > int numprocs = comm_ptr->local_size; > int tsndlen, trcvlen, snd_contig, rcv_contig, rc, i; > MPI_Aint sdt_true_lb, rdt_true_lb; > MPID_Datatype *dt_null = NULL; > > MPIDI_Datatype_get_info(sendcount, sendtype, snd_contig, > tsndlen, dt_null, sdt_true_lb); > MPIDI_Datatype_get_info(recvcount, recvtype, rcv_contig, > trcvlen, dt_null, rdt_true_lb); > > if(sendcount == 0 || recvcount == 0) > return MPI_SUCCESS; > > /* We only keep one protocol - alltoallv, but the > * use flag is separate. */ > if(!comm_ptr->dcmf.alltoalls || > !snd_contig || > !rcv_contig || > tsndlen != trcvlen || > numprocs < 2 || > !MPIDI_CollectiveProtocols.alltoall.usetorus || > !(DCMF_Geometry_analyze(&comm_ptr->dcmf.geometry, > &MPIDI_CollectiveProtocols.alltoallv.torus))) > { > return MPIR_Alltoall(sendbuf, sendcount, sendtype, > recvbuf, recvcount, recvtype, > comm_ptr); > } > if(!comm_ptr->dcmf.sndlen) > comm_ptr->dcmf.sndlen = MPIU_Malloc(numprocs * sizeof(unsigned)); > if(!comm_ptr->dcmf.rcvlen) > comm_ptr->dcmf.rcvlen = MPIU_Malloc(numprocs * sizeof(unsigned)); > if(!comm_ptr->dcmf.sdispls) > comm_ptr->dcmf.sdispls = MPIU_Malloc(numprocs * sizeof(unsigned)); > if(!comm_ptr->dcmf.rdispls) > comm_ptr->dcmf.rdispls = MPIU_Malloc(numprocs * sizeof(unsigned)); > if(!comm_ptr->dcmf.sndcounters) > comm_ptr->dcmf.sndcounters = MPIU_Malloc(numprocs * sizeof(unsigned)); > if(!comm_ptr->dcmf.rcvcounters) > comm_ptr->dcmf.rcvcounters = MPIU_Malloc(numprocs * sizeof(unsigned)); > > if(!comm_ptr->dcmf.sndlen || !comm_ptr->dcmf.rcvlen || > !comm_ptr->dcmf.sdispls || !comm_ptr->dcmf.rdispls || > !comm_ptr->dcmf.sndcounters || !comm_ptr->dcmf.rcvcounters) > { > if(comm_ptr->dcmf.sndlen) MPIU_Free(comm_ptr->dcmf.sndlen); > if(comm_ptr->dcmf.rcvlen) MPIU_Free(comm_ptr->dcmf.rcvlen); > if(comm_ptr->dcmf.sdispls) MPIU_Free(comm_ptr->dcmf.sdispls); > if(comm_ptr->dcmf.rdispls) MPIU_Free(comm_ptr->dcmf.rdispls); > if(comm_ptr->dcmf.sndcounters) MPIU_Free(comm_ptr->dcmf.sndcounters); > if(comm_ptr->dcmf.rcvcounters) MPIU_Free(comm_ptr->dcmf.rcvcounters); > return MPIR_Err_create_code(MPI_SUCCESS, > MPIR_ERR_RECOVERABLE, > "MPI_Alltoall", > __LINE__, MPI_ERR_OTHER, "**nomem", 0); > } > > /* ---------------------------------------------- */ > /* Initialize the send buffers and lengths */ > /* pktInject is the number of packets to inject */ > /* per advance loop. The best performance is 2 */ > /* ---------------------------------------------- */ > for (i = 0; i < numprocs; i++) > { > comm_ptr->dcmf.sndlen [i] = tsndlen; > comm_ptr->dcmf.sdispls[i] = i * tsndlen; > comm_ptr->dcmf.rcvlen [i] = trcvlen; > comm_ptr->dcmf.rdispls[i] = i * trcvlen; > } > > /* ---------------------------------------------- */ > /* Create a message layer collective message */ > /* ---------------------------------------------- */ > > rc = torus_alltoall((char *)sendbuf + sdt_true_lb, > comm_ptr->dcmf.sndlen, > comm_ptr->dcmf.sdispls, > (char *)recvbuf + rdt_true_lb, > comm_ptr->dcmf.rcvlen, > comm_ptr->dcmf.rdispls, > comm_ptr->dcmf.sndcounters, > comm_ptr->dcmf.rcvcounters, > &comm_ptr->dcmf.geometry); > > return rc; > } diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/coll/alltoallv/Makefile.sm bgp-mpich2/src/mpid/dcmf/src/coll/alltoallv/Makefile.sm 0a1,3 > SUBDIRS= . > INCLUDES = -I${master_top_srcdir}/src/include -I${top_builddir}/src/include > lib${MPILIBNAME}_a_SOURCES = mpido_alltoallv.c diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/coll/alltoallv/mpido_alltoallv.c bgp-mpich2/src/mpid/dcmf/src/coll/alltoallv/mpido_alltoallv.c 0a1,165 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file src/coll/alltoallv/mpido_alltoallv.c > * \brief ??? > */ > > #include "mpido_coll.h" > > #pragma weak PMPIDO_Alltoallv = MPIDO_Alltoallv > /** > * ************************************************************************** > * \brief "Done" callback for collective alltoall message. > * ************************************************************************** > */ > > static void > cb_done(void *clientdata) > { > volatile unsigned *work_left = (unsigned *) clientdata; > *work_left = 0; > MPID_Progress_signal(); > return; > } > > static int torus_alltoallv(char *sendbuf, > unsigned *sndlen, > unsigned *sdispls, > char *recvbuf, > unsigned *rcvlen, > unsigned *rdispls, > unsigned *sndcounters, > unsigned *rcvcounters, > DCMF_Geometry_t *geometry) > { > int rc; > DCMF_CollectiveRequest_t request; > volatile unsigned active = 1; > DCMF_Callback_t callback = { cb_done, (void *) &active }; > // fprintf(stderr,"torus alltoallv\n"); > > rc = DCMF_Alltoallv(&MPIDI_CollectiveProtocols.alltoallv.torus, > &request, > callback, > DCMF_MATCH_CONSISTENCY, > geometry, > sendbuf, > sndlen, > sdispls, > recvbuf, > rcvlen, > rdispls, > sndcounters, > rcvcounters); > > MPID_PROGRESS_WAIT_WHILE(active); > return rc; > } > > > int > MPIDO_Alltoallv(void *sendbuf, > int *sendcounts, > int *senddispls, > MPI_Datatype sendtype, > void *recvbuf, > int *recvcounts, > int *recvdispls, > MPI_Datatype recvtype, > MPID_Comm *comm_ptr) > { > > int numprocs = comm_ptr->local_size; > int tsndlen, trcvlen, snd_contig, rcv_contig, rc ,i; > MPI_Aint sdt_true_lb, rdt_true_lb; > MPID_Datatype *dt_null = NULL; > > MPIDI_Datatype_get_info(1, sendtype, snd_contig, tsndlen, > dt_null, sdt_true_lb); > MPIDI_Datatype_get_info(1, recvtype, rcv_contig, trcvlen, > dt_null, rdt_true_lb); > > if(!comm_ptr->dcmf.alltoalls || > !snd_contig || > !rcv_contig || > tsndlen != trcvlen || > numprocs < 2 || > !MPIDI_CollectiveProtocols.alltoallv.usetorus || > !(DCMF_Geometry_analyze(&comm_ptr->dcmf.geometry, > &MPIDI_CollectiveProtocols.alltoallv.torus))) > { > return MPIR_Alltoallv(sendbuf, sendcounts, senddispls, sendtype, > recvbuf, recvcounts, recvdispls, recvtype, > comm_ptr); > } > > /* ---------------------------------------------- */ > /* Allocate all data needed by alltoallv algorithm */ > /* ---------------------------------------------- */ > if(!comm_ptr->dcmf.sndlen) > comm_ptr->dcmf.sndlen = MPIU_Malloc(numprocs * sizeof(unsigned)); > if(!comm_ptr->dcmf.rcvlen) > comm_ptr->dcmf.rcvlen = MPIU_Malloc(numprocs * sizeof(unsigned)); > if(!comm_ptr->dcmf.sdispls) > comm_ptr->dcmf.sdispls = MPIU_Malloc(numprocs * sizeof(unsigned)); > if(!comm_ptr->dcmf.rdispls) > comm_ptr->dcmf.rdispls = MPIU_Malloc(numprocs * sizeof(unsigned)); > if(!comm_ptr->dcmf.sndcounters) > comm_ptr->dcmf.sndcounters = MPIU_Malloc(numprocs * sizeof(unsigned)); > if(!comm_ptr->dcmf.rcvcounters) > comm_ptr->dcmf.rcvcounters = MPIU_Malloc(numprocs * sizeof(unsigned)); > > if(!comm_ptr->dcmf.sndlen || !comm_ptr->dcmf.rcvlen || > !comm_ptr->dcmf.sdispls || !comm_ptr->dcmf.rdispls || > !comm_ptr->dcmf.sndcounters || !comm_ptr->dcmf.rcvcounters) > { > if(comm_ptr->dcmf.sndlen) MPIU_Free(comm_ptr->dcmf.sndlen); > if(comm_ptr->dcmf.rcvlen) MPIU_Free(comm_ptr->dcmf.rcvlen); > if(comm_ptr->dcmf.sdispls) MPIU_Free(comm_ptr->dcmf.sdispls); > if(comm_ptr->dcmf.rdispls) MPIU_Free(comm_ptr->dcmf.rdispls); > if(comm_ptr->dcmf.sndcounters) MPIU_Free(comm_ptr->dcmf.sndcounters); > if(comm_ptr->dcmf.rcvcounters) MPIU_Free(comm_ptr->dcmf.rcvcounters); > return MPIR_Err_create_code(MPI_SUCCESS, > MPIR_ERR_RECOVERABLE, > "MPI_Alltoallv", > __LINE__, MPI_ERR_OTHER, "**nomem", 0); > } > > /* ---------------------------------------------- */ > /* Initialize the send buffers and lengths */ > /* pktInject is the number of packets to inject */ > /* per advance loop. The best performance is 2 */ > /* ---------------------------------------------- */ > for (i = 0; i < numprocs; i++) > { > comm_ptr->dcmf.sndlen [i] = tsndlen * sendcounts[i]; > comm_ptr->dcmf.sdispls[i] = tsndlen * senddispls[i]; > comm_ptr->dcmf.rcvlen [i] = trcvlen * recvcounts[i]; > comm_ptr->dcmf.rdispls[i] = trcvlen * recvdispls[i]; > } > > > /* ---------------------------------------------- */ > /* Create a message layer collective message */ > /* ---------------------------------------------- */ > > rc = torus_alltoallv((char *)sendbuf + sdt_true_lb, > comm_ptr->dcmf.sndlen, > comm_ptr->dcmf.sdispls, > (char *)recvbuf + rdt_true_lb, > comm_ptr->dcmf.rcvlen, > comm_ptr->dcmf.rdispls, > comm_ptr->dcmf.sndcounters, > comm_ptr->dcmf.rcvcounters, > &comm_ptr->dcmf.geometry); > > > return rc; > } diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/coll/alltoallw/Makefile.sm bgp-mpich2/src/mpid/dcmf/src/coll/alltoallw/Makefile.sm 0a1,3 > SUBDIRS= . > INCLUDES = -I${master_top_srcdir}/src/include -I${top_builddir}/src/include > lib${MPILIBNAME}_a_SOURCES = mpido_alltoallw.c diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/coll/alltoallw/mpido_alltoallw.c bgp-mpich2/src/mpid/dcmf/src/coll/alltoallw/mpido_alltoallw.c 0a1,181 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file src/coll/alltoallw/mpido_alltoallw.c > * \brief ??? > */ > > #include "mpido_coll.h" > > #pragma weak PMPIDO_Alltoallw = MPIDO_Alltoallw > /** > * ************************************************************************** > * \brief "Done" callback for collective alltoall message. > * ************************************************************************** > */ > > static void > cb_done(void *clientdata) > { > volatile unsigned *work_left = (unsigned *) clientdata; > *work_left = 0; > MPID_Progress_signal(); > return; > } > > static int torus_alltoallw(char *sendbuf, > unsigned *sndlen, > unsigned *sdispls, > char *recvbuf, > unsigned *rcvlen, > unsigned *rdispls, > unsigned *sndcounters, > unsigned *rcvcounters, > DCMF_Geometry_t *geometry) > { > int rc; > DCMF_CollectiveRequest_t request; > volatile unsigned active = 1; > DCMF_Callback_t callback = { cb_done, (void *) &active }; > > rc = DCMF_Alltoallv(&MPIDI_CollectiveProtocols.alltoallv.torus, > &request, > callback, > DCMF_MATCH_CONSISTENCY, > geometry, > sendbuf, > sndlen, > sdispls, > recvbuf, > rcvlen, > rdispls, > sndcounters, > rcvcounters); > > MPID_PROGRESS_WAIT_WHILE(active); > return rc; > } > > > int > MPIDO_Alltoallw(void *sendbuf, > int *sendcounts, > int *senddispls, > MPI_Datatype *sendtypes, > void *recvbuf, > int *recvcounts, > int *recvdispls, > MPI_Datatype *recvtypes, > MPID_Comm *comm_ptr) > { > > int numprocs = comm_ptr->local_size; > int *tsndlen, *trcvlen, snd_contig, rcv_contig, rc ,i; > MPI_Aint sdt_true_lb=0, rdt_true_lb=0; > MPID_Datatype *dt_null = NULL; > > tsndlen = MPIU_Malloc(numprocs * sizeof(unsigned)); > trcvlen = MPIU_Malloc(numprocs * sizeof(unsigned)); > if(!tsndlen || !trcvlen) > return MPIR_Err_create_code(MPI_SUCCESS, > MPIR_ERR_RECOVERABLE, > "MPI_Alltoallw", > __LINE__, MPI_ERR_OTHER, "**nomem", 0); > > for(i=0;i { > MPIDI_Datatype_get_info(1, sendtypes[i], snd_contig, tsndlen[i], > dt_null, sdt_true_lb); > MPIDI_Datatype_get_info(1, recvtypes[i], rcv_contig, trcvlen[i], > dt_null, rdt_true_lb); > > > if(!comm_ptr->dcmf.alltoalls || > !snd_contig || > !rcv_contig || > tsndlen[i] != trcvlen[i] || > numprocs < 2 || > !MPIDI_CollectiveProtocols.alltoallw.usetorus || > !(DCMF_Geometry_analyze(&comm_ptr->dcmf.geometry, > &MPIDI_CollectiveProtocols.alltoallv.torus))) > { > if(tsndlen) free(tsndlen); > if(trcvlen) free(trcvlen); > return MPIR_Alltoallw(sendbuf, sendcounts, senddispls, sendtypes, > recvbuf, recvcounts, recvdispls, recvtypes, > comm_ptr); > } > } > > /* ---------------------------------------------- */ > /* Allocate all data needed by alltoallv algorithm */ > /* ---------------------------------------------- */ > if(!comm_ptr->dcmf.sndlen) > comm_ptr->dcmf.sndlen = MPIU_Malloc(numprocs * sizeof(unsigned)); > if(!comm_ptr->dcmf.rcvlen) > comm_ptr->dcmf.rcvlen = MPIU_Malloc(numprocs * sizeof(unsigned)); > if(!comm_ptr->dcmf.sdispls) > comm_ptr->dcmf.sdispls = MPIU_Malloc(numprocs * sizeof(unsigned)); > if(!comm_ptr->dcmf.rdispls) > comm_ptr->dcmf.rdispls = MPIU_Malloc(numprocs * sizeof(unsigned)); > if(!comm_ptr->dcmf.sndcounters) > comm_ptr->dcmf.sndcounters = MPIU_Malloc(numprocs * sizeof(unsigned)); > if(!comm_ptr->dcmf.rcvcounters) > comm_ptr->dcmf.rcvcounters = MPIU_Malloc(numprocs * sizeof(unsigned)); > > if(!comm_ptr->dcmf.sndlen || !comm_ptr->dcmf.rcvlen || > !comm_ptr->dcmf.sdispls || !comm_ptr->dcmf.rdispls || > !comm_ptr->dcmf.sndcounters || !comm_ptr->dcmf.rcvcounters) > { > if(comm_ptr->dcmf.sndlen) MPIU_Free(comm_ptr->dcmf.sndlen); > if(comm_ptr->dcmf.rcvlen) MPIU_Free(comm_ptr->dcmf.rcvlen); > if(comm_ptr->dcmf.sdispls) MPIU_Free(comm_ptr->dcmf.sdispls); > if(comm_ptr->dcmf.rdispls) MPIU_Free(comm_ptr->dcmf.rdispls); > if(comm_ptr->dcmf.sndcounters) MPIU_Free(comm_ptr->dcmf.sndcounters); > if(comm_ptr->dcmf.rcvcounters) MPIU_Free(comm_ptr->dcmf.rcvcounters); > return MPIR_Err_create_code(MPI_SUCCESS, > MPIR_ERR_RECOVERABLE, > "MPI_Alltoallw", > __LINE__, MPI_ERR_OTHER, "**nomem", 0); > } > > /* ---------------------------------------------- */ > /* Initialize the send buffers and lengths */ > /* pktInject is the number of packets to inject */ > /* per advance loop. The best performance is 2 */ > /* ---------------------------------------------- */ > for (i = 0; i < numprocs; i++) > { > comm_ptr->dcmf.sndlen [i] = tsndlen[i] * sendcounts[i]; > comm_ptr->dcmf.sdispls[i] = senddispls[i]; > > comm_ptr->dcmf.rcvlen [i] = trcvlen[i] * recvcounts[i]; > comm_ptr->dcmf.rdispls[i] = recvdispls[i]; > } > > > /* ---------------------------------------------- */ > /* Create a message layer collective message */ > /* ---------------------------------------------- */ > > rc = torus_alltoallw((char *)sendbuf + sdt_true_lb, > comm_ptr->dcmf.sndlen, > comm_ptr->dcmf.sdispls, > (char *)recvbuf + rdt_true_lb, > comm_ptr->dcmf.rcvlen, > comm_ptr->dcmf.rdispls, > comm_ptr->dcmf.sndcounters, > comm_ptr->dcmf.rcvcounters, > &comm_ptr->dcmf.geometry); > > > if(tsndlen) free(tsndlen); > if(trcvlen) free(trcvlen); > return rc; > } diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/coll/barrier/Makefile.sm bgp-mpich2/src/mpid/dcmf/src/coll/barrier/Makefile.sm 0a1,3 > SUBDIRS= . > INCLUDES = -I${master_top_srcdir}/src/include -I${top_builddir}/src/include > lib${MPILIBNAME}_a_SOURCES = mpido_barrier.c diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/coll/barrier/mpido_barrier.c bgp-mpich2/src/mpid/dcmf/src/coll/barrier/mpido_barrier.c 0a1,85 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file src/coll/barrier/mpido_barrier.c > * \brief ??? > */ > > #include "mpido_coll.h" > > #pragma weak PMPIDO_Barrier = MPIDO_Barrier > > /** > * ************************************************************************** > * \brief "Done" callback for barrier messages. > * ************************************************************************** > */ > > static void > cb_done (void *clientdata) { > volatile unsigned *work_left = (unsigned *) clientdata; > *work_left = 0; > MPID_Progress_signal(); > return; > } > > static volatile unsigned mpid_globalbarrier_active = 0;// global active field for global barriers > static DCMF_Request_t mpid_globalbarrier_request; > static unsigned mpid_globalbarrier_restart = 0; > > > /** > * ************************************************************************** > * \brief General MPIDO_Barrier() implementation > * ************************************************************************** > */ > > int MPIDO_Barrier(MPID_Comm *comm_ptr) > { > volatile unsigned active; // local (thread safe) active field for non-global barriers > int rc; > MPID_Comm *comm_world; > MPID_Comm_get_ptr(MPI_COMM_WORLD, comm_world); > DCMF_Callback_t callback = { cb_done, (void *) &mpid_globalbarrier_active }; // use global active field by default > if(comm_ptr == comm_world && MPIDI_CollectiveProtocols.barrier.usegi) > { > mpid_globalbarrier_active = 1; // initialize global active field > > if (mpid_globalbarrier_restart) > { > rc = DCMF_Restart (&mpid_globalbarrier_request); > } > else > { > mpid_globalbarrier_restart = 1; > rc = DCMF_GlobalBarrier(&MPIDI_Protocols.globalbarrier, &mpid_globalbarrier_request, callback); > } > } > else > { > callback.clientdata = (void*) &active; // use local (thread safe) active field > active = 1; // initialize local (thread safe) active field > > /* geometry sets up proper barrier for the geometry at init time */ > rc = DCMF_Barrier (&comm_ptr->dcmf.geometry, > callback, > DCMF_MATCH_CONSISTENCY); > } > > if (rc == DCMF_SUCCESS) > { > MPID_PROGRESS_WAIT_WHILE(*(int*)callback.clientdata); // use local or global active field - whichever was set > } > else > { > rc = MPIR_Barrier(comm_ptr); > } > > return rc; > } diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/coll/bcast/Makefile.sm bgp-mpich2/src/mpid/dcmf/src/coll/bcast/Makefile.sm 0a1,3 > SUBDIRS= . > INCLUDES = -I${master_top_srcdir}/src/include -I${top_builddir}/src/include > lib${MPILIBNAME}_a_SOURCES = mpido_bcast.c diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/coll/bcast/mpido_bcast.c bgp-mpich2/src/mpid/dcmf/src/coll/bcast/mpido_bcast.c 0a1,257 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file src/coll/bcast/mpido_bcast.c > * \brief ??? > */ > > #include "mpido_coll.h" > > #pragma weak PMPIDO_Bcast = MPIDO_Bcast > /** > * ************************************************************************** > * \brief "Done" callback for collective broadcast message. > * ************************************************************************** > */ > > static void cb_done (void *clientdata) > { > volatile unsigned *work_left = (unsigned *) clientdata; > *work_left = 0; > MPID_Progress_signal(); > return; > } > > > static int tree_bcast(void * buffer, > int bytes, > int root, > DCMF_Geometry_t * geometry) > { > int rc; > DCMF_CollectiveRequest_t request; > volatile unsigned active = 1; > DCMF_Callback_t callback = { cb_done, (void *) &active }; > extern int DCMF_TREE_SMP_SHORTCUT; > if (DCMF_TREE_SMP_SHORTCUT) { > rc = DCMF_GlobalBcast(&MPIDI_Protocols.globalbcast, > (DCMF_Request_t *)&request, > callback, > DCMF_MATCH_CONSISTENCY, > root, > buffer, > bytes); > } else { > rc = DCMF_Broadcast(&MPIDI_CollectiveProtocols.broadcast.tree, > &request, > callback, > DCMF_MATCH_CONSISTENCY, > geometry, > root, > buffer, > bytes); > } > MPID_PROGRESS_WAIT_WHILE(active); > return rc; > } > > static int binom_bcast(void * buffer, > int bytes, > int root, > DCMF_Geometry_t * geometry) > { > int rc; > DCMF_CollectiveRequest_t request; > volatile unsigned active = 1; > DCMF_Callback_t callback = { cb_done, (void *) &active }; > rc = DCMF_Broadcast(&MPIDI_CollectiveProtocols.broadcast.binomial, > &request, > callback, > DCMF_MATCH_CONSISTENCY, > geometry, > root, > buffer, > bytes); > MPID_PROGRESS_WAIT_WHILE(active); > return rc; > } > > > static int rect_bcast(void * buffer, > int bytes, > int root, > DCMF_Geometry_t * geometry) > { > int rc; > DCMF_CollectiveRequest_t request; > volatile unsigned active = 1; > DCMF_Callback_t callback = { cb_done, (void *) &active }; > rc = DCMF_Broadcast(&MPIDI_CollectiveProtocols.broadcast.rectangle, > &request, > callback, > DCMF_MATCH_CONSISTENCY, > geometry, > root, > buffer, > bytes); > MPID_PROGRESS_WAIT_WHILE(active); > return rc; > } > > > int MPIDO_Bcast(void * buffer, > int count, > MPI_Datatype datatype, > int root, > MPID_Comm * comm_ptr) > { > int data_sz, dt_contig, rc; > > MPID_Datatype *dt_ptr; > MPI_Aint dt_true_lb; > MPID_Segment segment; > > char *data_buffer; > char *noncontigbuf = NULL; > > unsigned treeavail, binomavail, rectavail; > > if(comm_ptr->comm_kind != MPID_INTRACOMM || count == 0) > return MPIR_Bcast(buffer, count, datatype, root, comm_ptr); > > // assert(comm_ptr->comm_kind != MPID_INTRACOMM); > > treeavail = comm_ptr->dcmf.bcasttree; > > rectavail = > MPIDI_CollectiveProtocols.broadcast.userect && > DCMF_Geometry_analyze(&comm_ptr->dcmf.geometry, > &MPIDI_CollectiveProtocols.broadcast.rectangle); > > binomavail = > MPIDI_CollectiveProtocols.broadcast.usebinom && > DCMF_Geometry_analyze(&comm_ptr->dcmf.geometry, > &MPIDI_CollectiveProtocols.broadcast.binomial); > > > #warning need benchmark data here > int usingtree = 1 && treeavail; > int usingbinom = 1 && binomavail; > int usingrect = 1 && rectavail; > > > MPIDI_Datatype_get_info(count, > datatype, > dt_contig, > data_sz, > dt_ptr, > dt_true_lb); > > data_buffer = (char *)buffer+dt_true_lb; > > /* tree asserts if the data type size is actually 0. should we make > * tree deal with a 0-byte bcast? */ > if(data_sz ==0) > usingtree = 0; > > if(!dt_contig) > { > noncontigbuf = MPIU_Malloc(data_sz); > data_buffer = noncontigbuf; > if (noncontigbuf == NULL) > { > fprintf(stderr, > "Pack: Tree Bcast cannot allocate local non-contig pack buffer\n"); > MPID_Dump_stacks(); > MPID_Abort(NULL, MPI_ERR_NO_SPACE, 1, > "Fatal: Cannot allocate pack buffer"); > } > > > if(comm_ptr->rank == root) > { > /* Root: Pack Data */ > DLOOP_Offset last = data_sz; > MPID_Segment_init (buffer, count, datatype, &segment, 0); > MPID_Segment_pack (&segment, 0, &last, noncontigbuf); > } > } > > > if(usingtree) > { > // fprintf(stderr, > // "tree: root: %d, comm size: %d %d, context_id: %d\n", > // root, comm_ptr->local_size, > // comm_ptr->remote_size, comm_ptr->context_id); > > rc = tree_bcast(data_buffer, > data_sz, > comm_ptr->vcr[root]->lpid, > &comm_ptr->dcmf.geometry); > } > > else if(usingrect) > { > // fprintf(stderr, > // "rect: kind: %d, root: %d, comm size: %d %d, context_id: %d\n", > // comm_ptr->comm_kind, root, comm_ptr->local_size, > // comm_ptr->remote_size, comm_ptr->context_id); > > rc = rect_bcast(data_buffer, > data_sz, > comm_ptr->vcr[root]->lpid, > &comm_ptr->dcmf.geometry); > > } > else if(usingbinom) > { > // fprintf(stderr, > // "binom: root: %d, comm size: %d %d, context_id: %d\n", > // root, comm_ptr->local_size, > // comm_ptr->remote_size, comm_ptr->context_id); > > rc = binom_bcast(data_buffer, > data_sz, > comm_ptr->vcr[root]->lpid, > &comm_ptr->dcmf.geometry); > } > else > { > // fprintf(stderr, > // "mpi: root: %d, comm size: %d %d, context_id: %d\n", > // root, comm_ptr->local_size, > // comm_ptr->remote_size, comm_ptr->context_id); > > return MPIR_Bcast(buffer, count, datatype, root, comm_ptr); > } > > > if(!dt_contig) > { > if(comm_ptr->rank != root) > { > int smpi_errno, rmpi_errno; > MPIDI_msg_sz_t rcount; > MPIDI_DCMF_Buffer_copy (noncontigbuf, > data_sz, > MPI_CHAR, > &smpi_errno, > buffer, > count, > datatype, > &rcount, > &rmpi_errno); > } > MPIU_Free(noncontigbuf); > noncontigbuf = NULL; > } > return rc; > > } diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/coll/coll_utils.c bgp-mpich2/src/mpid/dcmf/src/coll/coll_utils.c 0a1,213 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file src/coll/coll_utils.c > * \brief ??? > */ > > #include "mpido_coll.h" > > int MPIDI_ConvertMPItoDCMF(MPI_Op op, DCMF_Op *dcmf_op, > MPI_Datatype datatype, DCMF_Dt *dcmf_dt) > { > int rc = 0; > > switch(op) > { > case MPI_SUM: > *dcmf_op = DCMF_SUM; > break; > case MPI_PROD: > if(datatype == MPI_COMPLEX || datatype == MPI_DOUBLE_COMPLEX) > return -1; > *dcmf_op = DCMF_PROD; > rc = NOTTREEOP; > break; > case MPI_MAX: > *dcmf_op = DCMF_MAX; > break; > case MPI_MIN: > *dcmf_op = DCMF_MIN; > break; > case MPI_LAND: /* orange book, page 231 */ > if(datatype == MPI_LOGICAL || datatype == MPI_INT || > datatype == MPI_INTEGER || datatype == MPI_LONG || > datatype == MPI_UNSIGNED|| datatype == MPI_UNSIGNED_LONG) > { > *dcmf_op = DCMF_LAND; > rc = NOTTREEOP; > } > else return -1; > break; > case MPI_LOR: > if(datatype == MPI_LOGICAL || datatype == MPI_INT || > datatype == MPI_INTEGER || datatype == MPI_LONG || > datatype == MPI_UNSIGNED|| datatype == MPI_UNSIGNED_LONG) > { > *dcmf_op = DCMF_LOR; > rc = NOTTREEOP; > } > else return -1; > break; > case MPI_LXOR: > if(datatype == MPI_LOGICAL || datatype == MPI_INT || > datatype == MPI_INTEGER || datatype == MPI_LONG || > datatype == MPI_UNSIGNED|| datatype == MPI_UNSIGNED_LONG) > { > *dcmf_op = DCMF_LXOR; > rc = NOTTREEOP; > } > else return -1; > break; > case MPI_BAND: > if(datatype == MPI_LONG || datatype == MPI_INTEGER || > datatype == MPI_BYTE || datatype == MPI_UNSIGNED || > datatype == MPI_INT || datatype == MPI_UNSIGNED_LONG) > { > *dcmf_op = DCMF_BAND; > } > else return -1; > break; > case MPI_BOR: > if(datatype == MPI_LONG || datatype == MPI_INTEGER || > datatype == MPI_BYTE || datatype == MPI_UNSIGNED || > datatype == MPI_INT || datatype == MPI_UNSIGNED_LONG) > { > *dcmf_op = DCMF_BOR; > } > else return -1; > break; > case MPI_BXOR: > if(datatype == MPI_LONG || datatype == MPI_INTEGER || > datatype == MPI_BYTE || datatype == MPI_UNSIGNED || > datatype == MPI_INT || datatype == MPI_UNSIGNED_LONG) > { > *dcmf_op = DCMF_BXOR; > } > else return -1; > break; > case MPI_MAXLOC: > *dcmf_op = DCMF_MAXLOC; > break; > case MPI_MINLOC: > *dcmf_op = DCMF_MINLOC; > break; > default: > *dcmf_dt = DCMF_UNDEFINED_DT; > *dcmf_op = DCMF_UNDEFINED_OP; > return -1; > } > int rc_tmp = rc; > switch(datatype) > { > case MPI_CHAR: > case MPI_SIGNED_CHAR: > case MPI_CHARACTER: > *dcmf_dt = DCMF_SIGNED_CHAR; > return NOTTREEOP; > break; > > case MPI_UNSIGNED_CHAR: > case MPI_BYTE: > *dcmf_dt = DCMF_UNSIGNED_CHAR; > return NOTTREEOP; > break; > > case MPI_INT: > case MPI_INTEGER: > case MPI_LONG: > *dcmf_dt = DCMF_SIGNED_INT; > break; > > case MPI_UNSIGNED: > case MPI_UNSIGNED_LONG: > *dcmf_dt = DCMF_UNSIGNED_INT; > break; > > case MPI_SHORT: > *dcmf_dt = DCMF_SIGNED_SHORT; > break; > > case MPI_UNSIGNED_SHORT: > *dcmf_dt = DCMF_UNSIGNED_SHORT; > break; > > > case MPI_FLOAT: > case MPI_REAL: > *dcmf_dt = DCMF_FLOAT; > if(op != MPI_MAX || op != MPI_MIN ) > return NOTTREEOP; > break; > > case MPI_DOUBLE: > case MPI_DOUBLE_PRECISION: > *dcmf_dt = DCMF_DOUBLE; > break; > > case MPI_LONG_DOUBLE: > *dcmf_dt = DCMF_LONG_DOUBLE; > if(op == MPI_LAND || op == MPI_LOR || op == MPI_LXOR) > return -1; > return NOTTREEOP; > break; > > case MPI_LONG_LONG: > *dcmf_dt = DCMF_UNSIGNED_LONG_LONG; > break; > > case MPI_DOUBLE_COMPLEX: > *dcmf_dt = DCMF_DOUBLE_COMPLEX; > return NOTTREEOP; > break; > > case MPI_COMPLEX: > *dcmf_dt = DCMF_SINGLE_COMPLEX; > return NOTTREEOP; > break; > > case MPI_LOGICAL: > *dcmf_dt = DCMF_LOGICAL; > break; > > case MPI_FLOAT_INT: > *dcmf_dt = DCMF_LOC_FLOAT_INT; > break; > > case MPI_DOUBLE_INT: > *dcmf_dt = DCMF_LOC_DOUBLE_INT; > break; > > case MPI_LONG_INT: > case MPI_2INT: > case MPI_2INTEGER: > *dcmf_dt = DCMF_LOC_2INT; > break; > > case MPI_SHORT_INT: > *dcmf_dt = DCMF_LOC_SHORT_INT; > break; > > case MPI_2REAL: > *dcmf_dt = DCMF_LOC_2FLOAT; > break; > > case MPI_2DOUBLE_PRECISION: > *dcmf_dt = DCMF_LOC_2DOUBLE; > break; > > default: > *dcmf_dt = DCMF_UNDEFINED_DT; > *dcmf_op = DCMF_UNDEFINED_OP; > return -1; > } > if(rc_tmp ==NOTTREEOP) > return rc_tmp; > return rc; > } diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/coll/Makefile.sm bgp-mpich2/src/mpid/dcmf/src/coll/Makefile.sm 0a1,3 > SUBDIRS= . alltoall alltoallv alltoallw barrier bcast allreduce reduce allgather allgatherv > INCLUDES = -I${master_top_srcdir}/src/include -I${top_builddir}/src/include > lib${MPILIBNAME}_a_SOURCES = coll_utils.c unimpl.c diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/coll/reduce/Makefile.sm bgp-mpich2/src/mpid/dcmf/src/coll/reduce/Makefile.sm 0a1,3 > SUBDIRS= . > INCLUDES = -I${master_top_srcdir}/src/include -I${top_builddir}/src/include > lib${MPILIBNAME}_a_SOURCES = mpido_reduce.c diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/coll/reduce/mpido_reduce.c bgp-mpich2/src/mpid/dcmf/src/coll/reduce/mpido_reduce.c 0a1,323 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file src/coll/reduce/mpido_reduce.c > * \brief ??? > */ > > #include "mpido_coll.h" > > #pragma weak PMPIDO_Reduce = MPIDO_Reduce > > /** > * ************************************************************************** > * \brief "Done" callback for collective allreduce message. > * ************************************************************************** > */ > > static void cb_done (void *clientdata) > { > volatile unsigned *work_left = (unsigned *) clientdata; > *work_left = 0; > MPID_Progress_signal(); > > return; > } > > > static int tree_global_reduce(void * sendbuf, > void * recvbuf, > int count, > DCMF_Dt dcmf_dt, > DCMF_Op dcmf_op, > int root, > DCMF_Geometry_t * geometry) > { > int rc; > DCMF_CollectiveRequest_t request; > volatile unsigned active = 1; > DCMF_Callback_t callback = { cb_done, (void *) &active }; > rc = DCMF_GlobalAllreduce(&MPIDI_Protocols.globalallreduce, > (DCMF_Request_t *)&request, > callback, > DCMF_MATCH_CONSISTENCY, > root, > sendbuf, > recvbuf, > count, > dcmf_dt, > dcmf_op); > MPID_PROGRESS_WAIT_WHILE(active); > > return rc; > } > > static int tree_reduce(void * sendbuf, > void * recvbuf, > int count, > DCMF_Dt dcmf_dt, > DCMF_Op dcmf_op, > int root, > DCMF_Geometry_t * geometry) > { > int rc; > DCMF_CollectiveRequest_t request; > volatile unsigned active = 1; > DCMF_Callback_t callback = { cb_done, (void *) &active }; > rc = DCMF_Reduce(&MPIDI_CollectiveProtocols.reduce.tree, > &request, > callback, > DCMF_MATCH_CONSISTENCY, > geometry, > root, > sendbuf, > recvbuf, > count, > dcmf_dt, > dcmf_op); > MPID_PROGRESS_WAIT_WHILE(active); > > return rc; > } > > > static int binom_reduce(void * sendbuf, > void * recvbuf, > int count, > DCMF_Dt dcmf_dt, > DCMF_Op dcmf_op, > int root, > DCMF_Geometry_t * geometry) > { > int rc; > DCMF_CollectiveRequest_t request; > volatile unsigned active = 1; > DCMF_Callback_t callback = { cb_done, (void *) &active }; > > rc = DCMF_Reduce(&MPIDI_CollectiveProtocols.reduce.binomial, > &request, > callback, > DCMF_MATCH_CONSISTENCY, > geometry, > root, > sendbuf, > recvbuf, > count, > dcmf_dt, > dcmf_op); > > MPID_PROGRESS_WAIT_WHILE(active); > return rc; > } > > static int rect_reduce(void * sendbuf, > void * recvbuf, > int count, > DCMF_Dt dcmf_dt, > DCMF_Op dcmf_op, > int root, > DCMF_Geometry_t * geometry) > { > int rc; > DCMF_CollectiveRequest_t request; > volatile unsigned active = 1; > DCMF_Callback_t callback = { cb_done, (void *) &active }; > > rc = DCMF_Reduce(&MPIDI_CollectiveProtocols.reduce.rectangle, > &request, > callback, > DCMF_MATCH_CONSISTENCY, > geometry, > root, > sendbuf, > recvbuf, > count, > dcmf_dt, > dcmf_op); > > MPID_PROGRESS_WAIT_WHILE(active); > return rc; > } > > > > static int rectring_reduce(void * sendbuf, > void * recvbuf, > int count, > DCMF_Dt dcmf_dt, > DCMF_Op dcmf_op, > int root, > DCMF_Geometry_t * geometry) > { > int rc; > DCMF_CollectiveRequest_t request; > volatile unsigned active = 1; > DCMF_Callback_t callback = { cb_done, (void *) &active }; > > rc = DCMF_Reduce(&MPIDI_CollectiveProtocols.reduce.rectanglering, > &request, > callback, > DCMF_MATCH_CONSISTENCY, > geometry, > root, > sendbuf, > recvbuf, > count, > dcmf_dt, > dcmf_op); > > MPID_PROGRESS_WAIT_WHILE(active); > return rc; > } > > > > int MPIDO_Reduce(void * sendbuf, > void * recvbuf, > int count, > MPI_Datatype datatype, > MPI_Op op, > int root, > MPID_Comm * comm_ptr) > { > int dt_contig, dt_extent, rc; > unsigned treeavail, rectavail, binomavail, rectringavail; > > MPID_Datatype *dt_ptr; > MPI_Aint dt_true_lb; > > DCMF_Dt dcmf_dt = DCMF_UNDEFINED_DT; > DCMF_Op dcmf_op = DCMF_UNDEFINED_OP; > > if(count == 0) > return MPI_SUCCESS; > > treeavail = comm_ptr->dcmf.reducetree | comm_ptr->dcmf.reduceccmitree; > > rc = MPIDI_ConvertMPItoDCMF(op, &dcmf_op, datatype, &dcmf_dt); > > extern int DCMF_TREE_SMP_SHORTCUT; > > if(rc == 0 && treeavail && comm_ptr->local_size > 2) > { > if(sendbuf == MPI_IN_PLACE) > sendbuf = recvbuf; > if(DCMF_TREE_SMP_SHORTCUT && comm_ptr->dcmf.reducetree) > rc = tree_global_reduce(sendbuf, > recvbuf, > count, > dcmf_dt, > dcmf_op, > comm_ptr->vcr[root]->lpid, > &comm_ptr->dcmf.geometry); > else > rc = tree_reduce(sendbuf, > recvbuf, > count, > dcmf_dt, > dcmf_op, > comm_ptr->vcr[root]->lpid, > &comm_ptr->dcmf.geometry); > return rc; > } > > /* quick exit conditions */ > if(comm_ptr->comm_kind != MPID_INTRACOMM) > return MPIR_Reduce(sendbuf, recvbuf, count, datatype, op, root, comm_ptr); > > /* check geometry for possibilities */ > rectavail = MPIDI_CollectiveProtocols.reduce.userect && > DCMF_Geometry_analyze(&comm_ptr->dcmf.geometry, > &MPIDI_CollectiveProtocols.reduce.rectangle); > > rectringavail = MPIDI_CollectiveProtocols.reduce.userectring && > DCMF_Geometry_analyze(&comm_ptr->dcmf.geometry, > &MPIDI_CollectiveProtocols.reduce.rectanglering); > > binomavail = MPIDI_CollectiveProtocols.reduce.usebinom && > DCMF_Geometry_analyze(&comm_ptr->dcmf.geometry, > &MPIDI_CollectiveProtocols.reduce.binomial); > > > > MPIDI_Datatype_get_info(count, > datatype, > dt_contig, > dt_extent, > dt_ptr, > dt_true_lb); > > > rc = MPIDI_ConvertMPItoDCMF(op, &dcmf_op, datatype, &dcmf_dt); > /* return conditions */ > if( > // unsupported datatype or op > rc == -1 || > // no optimized topologies for this geometry > (!rectavail && !binomavail && !rectringavail) || > // return to mpich for 1 processor reduce > (comm_ptr -> local_size <=2)) > { > return MPIR_Reduce(sendbuf, recvbuf, count, datatype, op, root, comm_ptr); > } > > /* at this point, decide which network/algorithm we are using based on > * benchmark data, the op, the type, etc, etc > * until then just pick rectangle then binomial based on availability*/ > unsigned usingbinom=1 && binomavail; > unsigned usingrect=1 && rectavail; > unsigned usingrectring=1 && rectringavail; > > > if(sendbuf != MPI_IN_PLACE) > { > // int err = > // MPIR_Localcopy(sendbuf, count, datatype, recvbuf, count, datatype); > // if (err) return err; > } > else > sendbuf = recvbuf; > > if(usingrect) > { > // fprintf(stderr,"rect reduce count: %d, dt: %d, op: %d, send: 0x%x, recv: 0x%x\n", count, dcmf_dt, dcmf_op, sendbuf, recvbuf); > rc = rect_reduce(sendbuf, > recvbuf, > count, > dcmf_dt, > dcmf_op, > comm_ptr->vcr[root]->lpid, > &comm_ptr->dcmf.geometry); > } > else if(usingbinom) > { > // fprintf(stderr,"binom reduce count: %d, dt: %d, op: %d, send: 0x%x, recv: 0x%x\n", count, dcmf_dt, dcmf_op, sendbuf, recvbuf); > rc = binom_reduce(sendbuf, > recvbuf, > count, > dcmf_dt, > dcmf_op, > comm_ptr->vcr[root]->lpid, > &comm_ptr->dcmf.geometry); > } > else if(usingrectring) > { > // fprintf(stderr,"rectring reduce count: %d, dt: %d, op: %d, send: 0x%x, recv: 0x%x\n", count, dcmf_dt, dcmf_op, sendbuf, recvbuf); > rc = rectring_reduce(sendbuf, > recvbuf, > count, > dcmf_dt, > dcmf_op, > comm_ptr->vcr[root]->lpid, > &comm_ptr->dcmf.geometry); > } > > return rc; > > } diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/coll/unimpl.c bgp-mpich2/src/mpid/dcmf/src/coll/unimpl.c 0a1,115 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file src/coll/unimpl.c > * \brief Function prototypes for the optimized collective routines > */ > > #include "mpido_coll.h" > > /* These are collectives we don't optimize. But if we add these as weak > * aliases people could implement device-level versions and override > * these functions > */ > > #pragma weak PMPIDO_Gather = MPIDO_Gather > int MPIDO_Gather(void *sendbuf, > int sendcount, > MPI_Datatype sendtype, > void *recvbuf, > int recvcount, > MPI_Datatype recvtype, > int root, > MPID_Comm * comm_ptr) > { > return MPIR_Gather(sendbuf, sendcount, sendtype, > recvbuf, recvcount, recvtype, > root, comm_ptr); > } > > #pragma weak PMPIDO_Gatherv = MPIDO_Gatherv > int MPIDO_Gatherv(void *sendbuf, > int sendcount, > MPI_Datatype sendtype, > void *recvbuf, > int *recvcounts, > int *displs, > MPI_Datatype recvtype, > int root, > MPID_Comm * comm_ptr) > { > return MPIR_Gatherv(sendbuf, sendcount, sendtype, > recvbuf, recvcounts, displs, recvtype, > root, comm_ptr); > } > > #pragma weak PMPIDO_Scatter = MPIDO_Scatter > int MPIDO_Scatter(void *sendbuf, > int sendcount, > MPI_Datatype sendtype, > void *recvbuf, > int recvcount, > MPI_Datatype recvtype, > int root, > MPID_Comm * comm_ptr) > { > return MPIR_Scatter(sendbuf, sendcount, sendtype, > recvbuf, recvcount, recvtype, > root, comm_ptr); > } > > #pragma weak PMPIDO_Scatterv = MPIDO_Scatterv > int MPIDO_Scatterv(void *sendbuf, > int *sendcounts, > int *displs, > MPI_Datatype sendtype, > void *recvbuf, > int recvcount, > MPI_Datatype recvtype, > int root, > MPID_Comm * comm_ptr) > { > return MPIR_Scatterv(sendbuf, sendcounts, displs, sendtype, > recvbuf, recvcount, recvtype, > root, comm_ptr); > } > > #pragma weak PMPIDO_Reduce_scatter = MPIDO_Reduce_scatter > int MPIDO_Reduce_scatter(void *sendbuf, > void *recvbuf, > int *recvcounts, > MPI_Datatype datatype, > MPI_Op op, > MPID_Comm * comm_ptr) > { > return MPIR_Reduce_scatter(sendbuf, recvbuf, recvcounts, datatype, > op, comm_ptr); > } > > #pragma weak PMPIDO_Scan = MPIDO_Scan > int MPIDO_Scan(void *sendbuf, > void *recvbuf, > int count, > MPI_Datatype datatype, > MPI_Op op, > MPID_Comm * comm_ptr) > { > return MPIR_Scan(sendbuf, recvbuf, count, datatype, op, comm_ptr); > } > > #pragma weak PMPIDO_Exscan = MPIDO_Exscan > int MPIDO_Exscan(void *sendbuf, > void *recvbuf, > int count, > MPI_Datatype datatype, > MPI_Op op, > MPID_Comm * comm_ptr) > { > return MPIR_Exscan(sendbuf, recvbuf, count, datatype, op, comm_ptr); > } diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/comm/collselect/Makefile.sm bgp-mpich2/src/mpid/dcmf/src/comm/collselect/Makefile.sm 0a1,3 > SUBDIRS= . > INCLUDES = -I${master_top_srcdir}/src/include -I${top_builddir}/src/include > lib${MPILIBNAME}_a_SOURCES = mpid_coll.c diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/comm/collselect/mpid_coll.c bgp-mpich2/src/mpid/dcmf/src/comm/collselect/mpid_coll.c 0a1,547 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file src/comm/collselect/mpid_coll.c > * \brief Collective setup > */ > #include "mpido_coll.h" > > > #warning reasonable hack for now > #define MAXGEOMETRIES 65536 > > > static DCMF_Geometry_t *mpid_geometrytable[MAXGEOMETRIES]; > MPIDI_CollectiveProtocol_t MPIDI_CollectiveProtocols; > > /* > * geometries have a 'comm' ID which needs to be equivalently unique as > * MPIs context_ids. So, we set geometry comm to context_id. Unfortunately > * there is no trivial way to convert a context_id back to which MPI comm > * it belongs to so this gross table is here for now. It will be replaced > * probably with a lazy allocated list. Whatever goes here will have to be > * cleaned up in comm_destroy as well > */ > static DCMF_Geometry_t * > getGeometryRequest(int comm) > { > assert(mpid_geometrytable[comm%MAXGEOMETRIES] != NULL); > return mpid_geometrytable[comm%MAXGEOMETRIES]; > } > > > > static int barriers_num=0; > static DCMF_CollectiveProtocol_t *barriers[DCMF_NUM_BARRIER_PROTOCOLS]; > > static inline int BARRIER_REGISTER(DCMF_Barrier_Protocol proto, > DCMF_CollectiveProtocol_t *proto_ptr, > DCMF_Barrier_Configuration_t *config) > { > int rc; > config->protocol = proto; > rc = DCMF_Barrier_register(proto_ptr, config); > if (rc == DCMF_SUCCESS) > barriers[barriers_num++] = proto_ptr; > MPID_assert_debug(barriers_num <= DCMF_NUM_BARRIER_PROTOCOLS); > return rc; > } > > static int local_barriers_num=0; > /* Local barriers PLUS room for one standard/global barrier (DCMF_TORUS_BINOMIAL_BARRIER_PROTOCOL)*/ > static DCMF_CollectiveProtocol_t *local_barriers[DCMF_NUM_LOCAL_BARRIER_PROTOCOLS+1]; > > static inline int LOCAL_BARRIER_REGISTER(DCMF_Barrier_Protocol proto, > DCMF_CollectiveProtocol_t *proto_ptr, > DCMF_Barrier_Configuration_t *config) > { > int rc; > config->protocol = proto; > rc = DCMF_Barrier_register(proto_ptr, config); > if (rc == DCMF_SUCCESS) > local_barriers[local_barriers_num++] = proto_ptr; > MPID_assert_debug(local_barriers_num <= DCMF_NUM_LOCAL_BARRIER_PROTOCOLS+1); > return rc; > } > > static inline int BROADCAST_REGISTER(DCMF_Broadcast_Protocol proto, > DCMF_CollectiveProtocol_t *proto_ptr, > DCMF_Broadcast_Configuration_t *config) > { > config->protocol = proto; > return DCMF_Broadcast_register(proto_ptr, config); > } > > static inline int ALLREDUCE_REGISTER(DCMF_Allreduce_Protocol proto, > DCMF_CollectiveProtocol_t *proto_ptr, > DCMF_Allreduce_Configuration_t *config) > { > config->protocol = proto; > return DCMF_Allreduce_register(proto_ptr, config); > } > > static inline int ALLTOALLV_REGISTER(DCMF_Alltoallv_Protocol proto, > DCMF_CollectiveProtocol_t *proto_ptr, > DCMF_Alltoallv_Configuration_t *config) > { > config->protocol = proto; > return DCMF_Alltoallv_register(proto_ptr, config); > } > > static inline int REDUCE_REGISTER(DCMF_Reduce_Protocol proto, > DCMF_CollectiveProtocol_t *proto_ptr, > DCMF_Reduce_Configuration_t *config) > { > config->protocol = proto; > return DCMF_Reduce_register(proto_ptr, config); > } > > > > /** \brief Helper used to register all the collective protocols at initialization */ > void MPIDI_Coll_register(void) > { > DCMF_Barrier_Configuration_t barrier_config; > DCMF_Broadcast_Configuration_t broadcast_config; > DCMF_Allreduce_Configuration_t allreduce_config; > DCMF_Alltoallv_Configuration_t alltoallv_config; > DCMF_Reduce_Configuration_t reduce_config; > DCMF_GlobalBarrier_Configuration_t gbarrier_config; > DCMF_GlobalBcast_Configuration_t gbcast_config; > DCMF_GlobalAllreduce_Configuration_t gallreduce_config; > > DCMF_Result rc; > > /* Register the global functions first */ > > /* ---------------------------------- */ > /* Register global barrier */ > /* ---------------------------------- */ > gbarrier_config.protocol = DCMF_GI_GLOBALBARRIER_PROTOCOL; > rc = DCMF_GlobalBarrier_register(&MPIDI_Protocols.globalbarrier, > &gbarrier_config); > /* registering the global barrier failed, so don't use it */ > if(rc != DCMF_SUCCESS) > { > MPIDI_CollectiveProtocols.barrier.usegi = 0; > } > > > /* ---------------------------------- */ > /* Register global broadcast */ > /* ---------------------------------- */ > gbcast_config.protocol = DCMF_TREE_GLOBALBCAST_PROTOCOL; > rc = DCMF_GlobalBcast_register(&MPIDI_Protocols.globalbcast, &gbcast_config); > > /* most likely, we lack shared memory and therefore can't use this */ > if(rc != DCMF_SUCCESS) > { > MPIDI_CollectiveProtocols.broadcast.usetree = 0; > } > > /* ---------------------------------- */ > /* Register global allreduce */ > /* ---------------------------------- */ > gallreduce_config.protocol = DCMF_TREE_GLOBALALLREDUCE_PROTOCOL; > rc = DCMF_GlobalAllreduce_register(&MPIDI_Protocols.globalallreduce, > &gallreduce_config); > > /* most likely, we lack shared memory and therefore can't use this */ > /* reduce uses the allreduce protocol */ > if(rc != DCMF_SUCCESS) > { > /* Try the ccmi tree if we were trying global tree */ > MPIDI_CollectiveProtocols.allreduce.useccmitree = MPIDI_CollectiveProtocols.allreduce.usetree; > MPIDI_CollectiveProtocols.reduce.useccmitree = MPIDI_CollectiveProtocols.reduce.usetree; > MPIDI_CollectiveProtocols.allreduce.usetree = 0; > MPIDI_CollectiveProtocols.reduce.usetree = 0; > } > > > /* register first barrier protocols now */ > barrier_config.cb_geometry = getGeometryRequest; > > /* set the function that will find the [all]reduce geometry on unexpected callbacks*/ > allreduce_config.cb_geometry = getGeometryRequest; > reduce_config.cb_geometry = getGeometryRequest; > > /* set configuration flags in the config*/ > allreduce_config.reuse_storage = MPIDI_CollectiveProtocols.allreduce.reusestorage; > reduce_config.reuse_storage = MPIDI_CollectiveProtocols.reduce.reusestorage; > > /* Other env vars can be checked at communicator creation time > * but barriers are associated with a geometry and this knowledge > * isn't available to mpido_barrier > */ > if(MPIDI_CollectiveProtocols.barrier.usegi) > { > if(BARRIER_REGISTER(DCMF_GI_BARRIER_PROTOCOL, > &MPIDI_CollectiveProtocols.barrier.gi, > &barrier_config) != DCMF_SUCCESS) > MPIDI_CollectiveProtocols.barrier.usegi = 0; > } > > /* > * Always register a binomial barrier for collectives in subcomms, just > * choose not to use it at mpido_barrier > */ > if(BARRIER_REGISTER(DCMF_TORUS_BINOMIAL_BARRIER_PROTOCOL, > &MPIDI_CollectiveProtocols.barrier.binomial, > &barrier_config) != DCMF_SUCCESS) > MPIDI_CollectiveProtocols.barrier.usebinom = 0; > > /* if we don't even get a binomial barrier, we are in trouble */ > MPID_assert_debug(barriers_num > 0); > > /* > * Register local barriers for the geometry. > * Both a true local lockbox barrier and a global binomial > * barrier (which can be used non-optimally). The geometry > * will decide internally if/which to use. > * They are not used directly by MPICH but must be initialized. > */ > if(MPIDI_CollectiveProtocols.localbarrier.uselockbox) > { > if(LOCAL_BARRIER_REGISTER(DCMF_LOCKBOX_BARRIER_PROTOCOL, > &MPIDI_CollectiveProtocols.localbarrier.lockbox, > &barrier_config) != DCMF_SUCCESS) > MPIDI_CollectiveProtocols.localbarrier.uselockbox = 0; > } > > /* > * Always register a binomial barrier for collectives in subcomms > */ > if(LOCAL_BARRIER_REGISTER(DCMF_TORUS_BINOMIAL_BARRIER_PROTOCOL, > &MPIDI_CollectiveProtocols.localbarrier.binomial, > &barrier_config) != DCMF_SUCCESS) > MPIDI_CollectiveProtocols.localbarrier.usebinom = 0; > > /* MPID doesn't care if this actually works. Let someone else > * handle problems as needed. > * MPID_assert_debug(local_barriers_num > 0); > */ > > > /* Register broadcast protocols */ > if(MPIDI_CollectiveProtocols.broadcast.usetree) > { > if(BROADCAST_REGISTER(DCMF_TREE_BROADCAST_PROTOCOL, > &MPIDI_CollectiveProtocols.broadcast.tree, > &broadcast_config) != DCMF_SUCCESS) > MPIDI_CollectiveProtocols.broadcast.usetree = 0; > } > > if(BROADCAST_REGISTER(DCMF_TORUS_RECTANGLE_BROADCAST_PROTOCOL, > &MPIDI_CollectiveProtocols.broadcast.rectangle, > &broadcast_config) != DCMF_SUCCESS) > MPIDI_CollectiveProtocols.broadcast.userect = 0; > > // BROADCAST_REGISTER(DCMF_TORUS_RECT_BCAST_3COLOR_PROTOCOL, > // &MPIDI_CollectiveProtocols.broadcast.rectangle.threecolor, > // &broadcast_config); > > if(BROADCAST_REGISTER(DCMF_TORUS_BINOMIAL_BROADCAST_PROTOCOL, > &MPIDI_CollectiveProtocols.broadcast.binomial, > &broadcast_config) != DCMF_SUCCESS) > MPIDI_CollectiveProtocols.broadcast.usebinom = 0; > > > /* Register allreduce protocols */ > if(MPIDI_CollectiveProtocols.allreduce.usetree || > MPIDI_CollectiveProtocols.allreduce.useccmitree) > { > if(ALLREDUCE_REGISTER(DCMF_TREE_ALLREDUCE_PROTOCOL, > &MPIDI_CollectiveProtocols.allreduce.tree, > &allreduce_config) != DCMF_SUCCESS) > { > MPIDI_CollectiveProtocols.allreduce.usetree = 0; > MPIDI_CollectiveProtocols.allreduce.useccmitree = 0; > } > } > > if(ALLREDUCE_REGISTER(DCMF_TREE_PIPELINED_ALLREDUCE_PROTOCOL, > &MPIDI_CollectiveProtocols.allreduce.pipelinedtree, > &allreduce_config) != DCMF_SUCCESS) > MPIDI_CollectiveProtocols.allreduce.usepipelinedtree = 0; > > if(ALLREDUCE_REGISTER(DCMF_TORUS_RECTANGLE_ALLREDUCE_PROTOCOL, > &MPIDI_CollectiveProtocols.allreduce.rectangle, > &allreduce_config) != DCMF_SUCCESS) > MPIDI_CollectiveProtocols.allreduce.userect = 0; > > if(ALLREDUCE_REGISTER(DCMF_TORUS_RECTANGLE_RING_ALLREDUCE_PROTOCOL, > &MPIDI_CollectiveProtocols.allreduce.rectanglering, > &allreduce_config) != DCMF_SUCCESS) > MPIDI_CollectiveProtocols.allreduce.userectring = 0; > > if(ALLREDUCE_REGISTER(DCMF_TORUS_BINOMIAL_ALLREDUCE_PROTOCOL, > &MPIDI_CollectiveProtocols.allreduce.binomial, > &allreduce_config) != DCMF_SUCCESS) > MPIDI_CollectiveProtocols.allreduce.usebinom = 0; > > /* Register alltoallv protocols */ > if(ALLTOALLV_REGISTER(DCMF_TORUS_ALLTOALLV_PROTOCOL, > &MPIDI_CollectiveProtocols.alltoallv.torus, > &alltoallv_config) != DCMF_SUCCESS) > { > MPIDI_CollectiveProtocols.alltoallv.usetorus = 0; > MPIDI_CollectiveProtocols.alltoallw.usetorus = 0; > MPIDI_CollectiveProtocols.alltoall.usetorus = 0; > } > > /* Register reduce protocols */ > if(MPIDI_CollectiveProtocols.reduce.usetree || > MPIDI_CollectiveProtocols.reduce.useccmitree) > { > if(REDUCE_REGISTER(DCMF_TREE_REDUCE_PROTOCOL, > &MPIDI_CollectiveProtocols.reduce.tree, > &reduce_config) != DCMF_SUCCESS) > { > MPIDI_CollectiveProtocols.reduce.usetree = 0; > MPIDI_CollectiveProtocols.reduce.useccmitree = 0; > } > } > > if(REDUCE_REGISTER(DCMF_TORUS_BINOMIAL_REDUCE_PROTOCOL, > &MPIDI_CollectiveProtocols.reduce.binomial, > &reduce_config) != DCMF_SUCCESS) > MPIDI_CollectiveProtocols.reduce.usebinom = 0; > > if(REDUCE_REGISTER(DCMF_TORUS_RECTANGLE_REDUCE_PROTOCOL, > &MPIDI_CollectiveProtocols.reduce.rectangle, > &reduce_config) != DCMF_SUCCESS) > MPIDI_CollectiveProtocols.reduce.userect = 0; > > if(REDUCE_REGISTER(DCMF_TORUS_RECTANGLE_RING_REDUCE_PROTOCOL, > &MPIDI_CollectiveProtocols.reduce.rectanglering, > &reduce_config) != DCMF_SUCCESS) > MPIDI_CollectiveProtocols.reduce.userectring = 0; > > } > > > /** > * \brief Create collective communicators > * > * Hook function to handle collective-specific optimization during communicator creation > */ > void MPIDI_Coll_Comm_create (MPID_Comm *comm) > { > MPID_assert (comm!= NULL); > > int global=0; > MPID_Comm *comm_world; > > if (comm->coll_fns) MPIU_Free(comm->coll_fns); > comm->coll_fns=NULL; /* !!! Intercomm_merge does not NULL the fcns, > * leading to stale functions for new comms. > * We'll null it here until argonne confirms > * this is the correct behavior of merge > */ > > /* comm-specific protocol flags */ > comm->dcmf.allreducetree = 1; > comm->dcmf.reducetree = 1; > comm->dcmf.allreduceccmitree = 1; > comm->dcmf.reduceccmitree = 1; > comm->dcmf.bcasttree = 1; > comm->dcmf.alltoalls = 1; > > /* ****************************************** */ > /* Allocate space for the collective pointers */ > /* ****************************************** */ > > comm->coll_fns = (MPID_Collops *)MPIU_Malloc(sizeof(MPID_Collops)); > MPID_assert(comm->coll_fns != NULL); > memset(comm->coll_fns, 0, sizeof(MPID_Collops)); > > > /* ****************************************** */ > /* Set all defaults */ > /* ****************************************** */ > comm->dcmf.worldranks = NULL; > > /* If we are an intracomm, MPICH should handle */ > if (comm->comm_kind != MPID_INTRACOMM) return; > /* User may disable all collectives */ > if (!MPIDI_Process.optimized.collectives) return; > > MPID_Comm_get_ptr(MPI_COMM_WORLD, comm_world); > MPID_assert_debug(comm_world != NULL); > > /* creates ranks array in comm, geometry stores pointer to this array */ > /* should we pass the returned int * to geometry_init? */ > MPIDI_Comm_worldranks_init(comm); > > > > if(MPIR_ThreadInfo.thread_provided == MPI_THREAD_MULTIPLE) > { > if(comm != comm_world) > { > global = 0; > /* alltoall protocols not entirely thread-safe so turn off for this > * communicator > */ > comm->dcmf.alltoalls = 0; > } > /* we are comm_world */ > else > global = 1; > } > else /* single MPI thread. */ > { > /* and if we are a dupe of comm_world, global context is also safe */ > if(comm->local_size == comm_world->local_size) > global = 1; > else > global = 0; > } > > > /* ****************************************** */ > /* These are ALL the pointers in the object */ > /* ****************************************** */ > > comm->coll_fns->Barrier = MPIDO_Barrier; > comm->coll_fns->Bcast = MPIDO_Bcast; > comm->coll_fns->Reduce = MPIDO_Reduce; > comm->coll_fns->Allreduce = MPIDO_Allreduce; > comm->coll_fns->Alltoall = MPIDO_Alltoall; > comm->coll_fns->Alltoallv = MPIDO_Alltoallv; > comm->coll_fns->Alltoallw = MPIDO_Alltoallw; > comm->coll_fns->Allgather = MPIDO_Allgather; > comm->coll_fns->Allgatherv = MPIDO_Allgatherv; > comm->coll_fns->Gather = MPIDO_Gather; > comm->coll_fns->Gatherv = MPIDO_Gatherv; > comm->coll_fns->Scatter = MPIDO_Scatter; > comm->coll_fns->Scatterv = MPIDO_Scatterv; > comm->coll_fns->Reduce_scatter = MPIDO_Reduce_scatter; > comm->coll_fns->Scan = MPIDO_Scan; > comm->coll_fns->Exscan = MPIDO_Exscan; > > > > > /* ******************************************************* */ > /* Setup Barriers and geometry for this communicator */ > /* ******************************************************* */ > DCMF_Geometry_initialize( > &comm->dcmf.geometry, > comm->context_id, > comm->dcmf.worldranks, > comm->local_size, > barriers, > barriers_num, > local_barriers, > local_barriers_num, > &comm->dcmf.barrier, > MPIDI_CollectiveProtocols.numcolors, > global); > > // fprintf(stderr, > // "context_id: %d, context_id mod MAX: %d\n", > // comm->context_id, (comm->context_id) % MAXGEOMETRIES); > mpid_geometrytable[(comm->context_id)%MAXGEOMETRIES] = &comm->dcmf.geometry; > > > if((MPIDI_CollectiveProtocols.allreduce.usetree || > MPIDI_CollectiveProtocols.allreduce.useccmitree) && > !DCMF_Geometry_analyze(&comm->dcmf.geometry, > &MPIDI_CollectiveProtocols.allreduce.tree)) > { > comm->dcmf.allreducetree = 0; > comm->dcmf.allreduceccmitree = 0; > } > else > { > comm->dcmf.allreducetree = MPIDI_CollectiveProtocols.allreduce.usetree; > comm->dcmf.allreduceccmitree = MPIDI_CollectiveProtocols.allreduce.useccmitree; > } > > if((MPIDI_CollectiveProtocols.reduce.usetree || > MPIDI_CollectiveProtocols.reduce.useccmitree) && > !DCMF_Geometry_analyze(&comm->dcmf.geometry, > &MPIDI_CollectiveProtocols.reduce.tree)) > { > comm->dcmf.reducetree = 0; > comm->dcmf.reduceccmitree = 0; > } > else > { > comm->dcmf.reducetree = MPIDI_CollectiveProtocols.reduce.usetree; > comm->dcmf.reduceccmitree = MPIDI_CollectiveProtocols.reduce.useccmitree; > } > > if(MPIDI_CollectiveProtocols.allreduce.usepipelinedtree && > !DCMF_Geometry_analyze(&comm->dcmf.geometry, > &MPIDI_CollectiveProtocols.allreduce.pipelinedtree)) > comm->dcmf.allreducepipelinedtree = 0; > else > comm->dcmf.allreducepipelinedtree = MPIDI_CollectiveProtocols.allreduce.usepipelinedtree; > > if(MPIDI_CollectiveProtocols.broadcast.usetree && > !DCMF_Geometry_analyze(&comm->dcmf.geometry, > &MPIDI_CollectiveProtocols.broadcast.tree)) > comm->dcmf.bcasttree = 0; > else > comm->dcmf.bcasttree = MPIDI_CollectiveProtocols.broadcast.usetree; > > comm->dcmf.sndlen = NULL; > comm->dcmf.rcvlen = NULL; > comm->dcmf.sdispls = NULL; > comm->dcmf.rdispls = NULL; > comm->dcmf.sndcounters = NULL; > comm->dcmf.rcvcounters = NULL; > if(MPIDI_CollectiveProtocols.alltoall.premalloc) > { > comm->dcmf.sndlen = MPIU_Malloc(sizeof(unsigned) * comm->local_size); > comm->dcmf.rcvlen = MPIU_Malloc(sizeof(unsigned) * comm->local_size); > comm->dcmf.sdispls = MPIU_Malloc(sizeof(unsigned) * comm->local_size); > comm->dcmf.rdispls = MPIU_Malloc(sizeof(unsigned) * comm->local_size); > comm->dcmf.sndcounters = MPIU_Malloc(sizeof(unsigned) * comm->local_size); > comm->dcmf.rcvcounters = MPIU_Malloc(sizeof(unsigned) * comm->local_size); > } > > MPIR_Barrier(comm); > } > > > /** > * \brief Destroy a communicator > * > * Hook function to handle collective-specific optimization during communicator destruction > * > * \note We want to free the associated coll_fns buffer at this time. > */ > void MPIDI_Coll_Comm_destroy (MPID_Comm *comm) > { > MPID_assert (comm != NULL); > if (comm->coll_fns) MPIU_Free(comm->coll_fns); comm->coll_fns = NULL; > if(comm->dcmf.worldranks) MPIU_Free(comm->dcmf.worldranks); > DCMF_Geometry_free(&comm->dcmf.geometry); > comm->dcmf.worldranks=NULL; > if(comm->dcmf.sndlen) > MPIU_Free(comm->dcmf.sndlen); > if(comm->dcmf.rcvlen) > MPIU_Free(comm->dcmf.rcvlen); > if(comm->dcmf.sdispls) > MPIU_Free(comm->dcmf.sdispls); > if(comm->dcmf.rdispls) > MPIU_Free(comm->dcmf.rdispls); > if(comm->dcmf.sndcounters) > MPIU_Free(comm->dcmf.sndcounters); > if(comm->dcmf.rcvcounters) > MPIU_Free(comm->dcmf.rcvcounters); > > comm->dcmf.sndlen = comm->dcmf.rcvlen = > comm->dcmf.sdispls = comm->dcmf.rdispls = > comm->dcmf.sndcounters = comm->dcmf.rcvcounters = NULL; > > } diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/comm/Makefile.sm bgp-mpich2/src/mpid/dcmf/src/comm/Makefile.sm 0a1,3 > SUBDIRS= . collselect topo > INCLUDES = -I${master_top_srcdir}/src/include -I${top_builddir}/src/include > lib${MPILIBNAME}_a_SOURCES = mpid_comm.c diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/comm/mpid_comm.c bgp-mpich2/src/mpid/dcmf/src/comm/mpid_comm.c 0a1,483 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file src/comm/mpid_comm.c > * \brief Communicator setup > */ > #include "mpido_coll.h" > > /** \brief Hook function to handle communicator-specific optimization (creation) */ > void > MPIDI_Comm_create (MPID_Comm *comm) > { > MPIDI_Coll_Comm_create(comm); > MPIDI_Topo_Comm_create(comm); > } > > > /** \brief Hook function to handle communicator-specific optimization (destruction) */ > void > MPIDI_Comm_destroy (MPID_Comm *comm) > { > MPIDI_Coll_Comm_destroy(comm); > MPIDI_Topo_Comm_destroy(comm); > } > > > static inline int > ENV_Int(char * env, int * dval) > { > int result; > if(env != NULL) > result = atoi(env); > else > result = *dval; > return *dval = result; > } > > static inline int > ENV_Bool(char * env, int * dval) > { > int result = *dval; > if(env != NULL) > { > if (strcmp(env, "0") == 0) > result = 0; > else if (strcmp(env, "0") == 1) > result = 1; > } > return *dval = result; > } > > /** \brief Checks the Environment variables at initialization and stores the results */ > void > MPIDI_Env_setup() > { > int dval = 0; > char *envopts; > > /* Initialize selection variables */ > /* turn these off in MPIDI_Coll_register if registration fails > * or based on env vars (below) */ > MPIDI_CollectiveProtocols.numcolors = 0; > MPIDI_CollectiveProtocols.barrier.usegi = 1; > MPIDI_CollectiveProtocols.barrier.usebinom = 1; > MPIDI_CollectiveProtocols.optbarrier = 1; > > MPIDI_CollectiveProtocols.localbarrier.uselockbox = 1; > MPIDI_CollectiveProtocols.localbarrier.usebinom = 1; > > MPIDI_CollectiveProtocols.broadcast.usetree = 1; > MPIDI_CollectiveProtocols.broadcast.userect = 1; > MPIDI_CollectiveProtocols.broadcast.usebinom = 1; > MPIDI_CollectiveProtocols.optbroadcast = 1; > > MPIDI_CollectiveProtocols.allreduce.reusestorage = 1; > MPIDI_CollectiveProtocols.allreduce.usetree = 1; > MPIDI_CollectiveProtocols.allreduce.usepipelinedtree = 0; // defaults to off > MPIDI_CollectiveProtocols.allreduce.useccmitree = 0; // defaults to off > MPIDI_CollectiveProtocols.allreduce.userect = 1; > MPIDI_CollectiveProtocols.allreduce.userectring = 0; // defaults to off > MPIDI_CollectiveProtocols.allreduce.usebinom = 1; > MPIDI_CollectiveProtocols.optallreduce = 1; > > MPIDI_CollectiveProtocols.reduce.reusestorage = 1; > MPIDI_CollectiveProtocols.reduce.usetree = 1; > MPIDI_CollectiveProtocols.reduce.useccmitree = 0; // defaults to off > MPIDI_CollectiveProtocols.reduce.userect = 1; > MPIDI_CollectiveProtocols.reduce.userectring = 0; // defaults to off > MPIDI_CollectiveProtocols.reduce.usebinom = 1; > MPIDI_CollectiveProtocols.optreduce = 1; > > MPIDI_CollectiveProtocols.optallgather = 1; > MPIDI_CollectiveProtocols.allgather.useallreduce = 1; > MPIDI_CollectiveProtocols.allgather.usebcast = 1; > MPIDI_CollectiveProtocols.allgather.usealltoallv = 1; > MPIDI_CollectiveProtocols.optallgatherv = 1; > MPIDI_CollectiveProtocols.allgatherv.useallreduce = 1; > MPIDI_CollectiveProtocols.allgatherv.usebcast = 1; > MPIDI_CollectiveProtocols.allgatherv.usealltoallv = 1; > > MPIDI_CollectiveProtocols.alltoallv.usetorus = 1; > MPIDI_CollectiveProtocols.alltoallw.usetorus = 1; > MPIDI_CollectiveProtocols.alltoall.usetorus = 1; > MPIDI_CollectiveProtocols.alltoall.premalloc = 1; > > /* Set the verbose level */ > dval = 0; > ENV_Int(getenv("DCMF_VERBOSE"), &dval); > MPIDI_Process.verbose = dval; > > /* Enable the statistics */ > dval = 0; > ENV_Bool(getenv("DCMF_STATISTICS"), &dval); > MPIDI_Process.statistics = dval; > > /* Determine eager limit */ > dval = 1200; > ENV_Int(getenv("DCMF_RVZ"), &dval); > ENV_Int(getenv("DCMF_RZV"), &dval); > ENV_Int(getenv("DCMF_EAGER"), &dval); > MPIDI_Process.eager_limit = dval; > > /* Determine interrupt mode */ > dval = 0; > ENV_Bool(getenv("DCMF_INTERRUPT"), &dval); > ENV_Bool(getenv("DCMF_INTERRUPTS"), &dval); > MPIDI_Process.use_interrupts = dval; > > /* Set the status of the optimized topology functions */ > dval = 1; > ENV_Bool(getenv("DCMF_TOPOLOGY"), &dval); > MPIDI_Process.optimized.topology = dval; > > /* Set the status of the optimized collectives */ > dval = 1; > ENV_Bool(getenv("DCMF_COLLECTIVE"), &dval); > ENV_Bool(getenv("DCMF_COLLECTIVES"), &dval); > MPIDI_Process.optimized.collectives = dval; > dval = 1000; > ENV_Int(getenv("DCMF_RMA_PENDING"), &dval); > MPIDI_Process.rma_pending = dval; > > envopts = getenv("DCMF_BCAST"); > if(envopts != NULL) > { > if(strncasecmp(envopts, "M", 1) == 0) /* MPICH */ > { > MPIDI_CollectiveProtocols.broadcast.usetree = 0; > MPIDI_CollectiveProtocols.broadcast.userect = 0; > MPIDI_CollectiveProtocols.broadcast.usebinom = 0; > MPIDI_CollectiveProtocols.optbroadcast = 0; > } > else if(strncasecmp(envopts, "R", 1) == 0) /* Rectangle */ > { > MPIDI_CollectiveProtocols.broadcast.usetree = 0; > MPIDI_CollectiveProtocols.broadcast.usebinom = 0; > } > else if(strncasecmp(envopts, "B", 1) == 0) /* Binomial */ > { > MPIDI_CollectiveProtocols.broadcast.usetree = 0; > MPIDI_CollectiveProtocols.broadcast.userect = 0; > } > else if(strncasecmp(envopts, "T", 1) == 0) /* Tree */ > { > MPIDI_CollectiveProtocols.broadcast.userect = 0; > MPIDI_CollectiveProtocols.broadcast.usebinom = 0; > } > else > fprintf(stderr,"Invalid DCMF_BCAST option\n"); > } > > > > envopts = getenv("DCMF_NUMCOLORS"); > if(envopts != NULL) > { > int colors = atoi(envopts); > if(colors < 0 || colors > 3) > fprintf(stderr,"Invalid DCMF_NUMCOLORS option\n"); > else > MPIDI_CollectiveProtocols.numcolors = colors; > } > > > envopts = getenv("DCMF_ALLTOALL"); > if(envopts != NULL) > { > if(strncasecmp(envopts, "M", 1) == 0) /* MPICH */ > MPIDI_CollectiveProtocols.alltoall.usetorus = 0; > else if(strncasecmp(envopts, "T", 1) == 0) /* Torus */ > ; > /* This is on by default in MPIDI_Coll_register */ > /* MPIDI_CollectiveProtocols.alltoall.usetorus = 1; */ > else > fprintf(stderr,"Invalid DCMF_ALLTOALL option\n"); > } > > envopts = getenv("DCMF_ALLTOALL_PREMALLOC"); > if(envopts == NULL) > envopts = getenv("DCMF_ALLTOALLV_PREMALLOC"); > if(envopts == NULL) > envopts = getenv("DCMF_ALLTOALLW_PREMALLOC"); > if(envopts != NULL) > { /* Do not reuse the malloc'd storage */ > if(strncasecmp(envopts, "N", 1) == 0) > { > MPIDI_CollectiveProtocols.alltoall.premalloc = 0; > } > else if(strncasecmp(envopts, "Y", 1) == 0) /* defaults to Y */ > { > MPIDI_CollectiveProtocols.alltoall.premalloc = 1; > } > else > fprintf(stderr,"Invalid DCMF_ALLTOALL(VW)_PREMALLOC option\n"); > } > > > envopts = getenv("DCMF_ALLTOALLV"); > if(envopts != NULL) > { > if(strncasecmp(envopts, "M", 1) == 0) /* MPICH */ > MPIDI_CollectiveProtocols.alltoallv.usetorus = 0; > else if(strncasecmp(envopts, "T", 1) == 0) /* Torus */ > ; > /* This is on by default in MPIDI_Coll_register */ > /* MPIDI_CollectiveProtocols.alltoallv.usetorus = 1;*/ > else > fprintf(stderr,"Invalid DCMF_ALLTOALLV option\n"); > } > > envopts = getenv("DCMF_ALLTOALLW"); > if(envopts != NULL) > { > if(strncasecmp(envopts, "M", 1) == 0) /* MPICH */ > MPIDI_CollectiveProtocols.alltoallw.usetorus = 0; > else if(strncasecmp(envopts, "T", 1) == 0) /* Torus */ > ; > /* This is on by default in MPIDI_Coll_register */ > /* MPIDI_CollectiveProtocols.alltoallw.usetorus = 1;*/ > else > fprintf(stderr,"Invalid DCMF_ALLTOALLW option\n"); > } > > envopts = getenv("DCMF_ALLGATHER"); > if(envopts != NULL) > { > if(strncasecmp(envopts, "M", 1) == 0) /* MPICH */ > MPIDI_CollectiveProtocols.optallgather = 0; > else if(strncasecmp(envopts, "ALLR", 4) == 0) /* ALLREDUCE */ > { > MPIDI_CollectiveProtocols.allgather.useallreduce = 1; > MPIDI_CollectiveProtocols.allgather.usebcast = 0; > MPIDI_CollectiveProtocols.allgather.usealltoallv = 0; > } > else if(strncasecmp(envopts, "BCAST", 1) == 0) /* BCAST */ > { > MPIDI_CollectiveProtocols.allgather.useallreduce = 0; > MPIDI_CollectiveProtocols.allgather.usebcast = 1; > MPIDI_CollectiveProtocols.allgather.usealltoallv = 0; > } > else if(strncasecmp(envopts, "ALLT", 4) == 0) /* ALLTOALL */ > { > MPIDI_CollectiveProtocols.allgather.useallreduce = 0; > MPIDI_CollectiveProtocols.allgather.usebcast = 0; > MPIDI_CollectiveProtocols.allgather.usealltoallv = 1; > } > else > fprintf(stderr,"Invalid DCMF_ALLGATHER option\n"); > } > > envopts = getenv("DCMF_ALLGATHERV"); > if(envopts != NULL) > { > if(strncasecmp(envopts, "M", 1) == 0) /* MPICH */ > MPIDI_CollectiveProtocols.optallgatherv = 0; > else if(strncasecmp(envopts, "ALLR", 4) == 0) /* ALLREDUCE */ > { > MPIDI_CollectiveProtocols.allgatherv.useallreduce = 1; > MPIDI_CollectiveProtocols.allgatherv.usebcast = 0; > MPIDI_CollectiveProtocols.allgatherv.usealltoallv = 0; > } > else if(strncasecmp(envopts, "BCAST", 1) == 0) /* BCAST */ > { > MPIDI_CollectiveProtocols.allgatherv.useallreduce = 0; > MPIDI_CollectiveProtocols.allgatherv.usebcast = 1; > MPIDI_CollectiveProtocols.allgatherv.usealltoallv = 0; > } > else if(strncasecmp(envopts, "ALLT", 4) == 0) /* ALLTOALL */ > { > MPIDI_CollectiveProtocols.allgatherv.useallreduce = 0; > MPIDI_CollectiveProtocols.allgatherv.usebcast = 0; > MPIDI_CollectiveProtocols.allgatherv.usealltoallv = 1; > } > else > fprintf(stderr,"Invalid DCMF_ALLGATHERV option\n"); > } > > envopts = getenv("DCMF_ALLREDUCE"); > if(envopts != NULL) > { > if(strncasecmp(envopts, "M", 1) == 0) /* MPICH */ > { > MPIDI_CollectiveProtocols.allreduce.usetree = 0; > MPIDI_CollectiveProtocols.allreduce.userect = 0; > MPIDI_CollectiveProtocols.allreduce.usebinom = 0; > MPIDI_CollectiveProtocols.optallreduce = 0; > } > else if(strncasecmp(envopts, "RI", 2) == 0) /* Rectangle Ring*/ > { > MPIDI_CollectiveProtocols.allreduce.userectring = 1;// defaults to off > MPIDI_CollectiveProtocols.allreduce.userect = 0; > MPIDI_CollectiveProtocols.allreduce.usetree = 0; > MPIDI_CollectiveProtocols.allreduce.usebinom = 0; > } > else if(strncasecmp(envopts, "R", 1) == 0) /* Rectangle */ > { > MPIDI_CollectiveProtocols.allreduce.usetree = 0; > MPIDI_CollectiveProtocols.allreduce.usebinom = 0; > } > else if(strncasecmp(envopts, "B", 1) == 0) /* Binomial */ > { > MPIDI_CollectiveProtocols.allreduce.usetree = 0; > MPIDI_CollectiveProtocols.allreduce.userect = 0; > } > else if(strncasecmp(envopts, "T", 1) == 0) /* Tree */ > { > MPIDI_CollectiveProtocols.allreduce.usebinom = 0; > MPIDI_CollectiveProtocols.allreduce.userect = 0; > } > else if(strncasecmp(envopts, "C", 1) == 0) /* CCMI Tree */ > { > MPIDI_CollectiveProtocols.allreduce.useccmitree = 1;// defaults to off > MPIDI_CollectiveProtocols.allreduce.usetree = 0; > MPIDI_CollectiveProtocols.allreduce.usebinom = 0; > MPIDI_CollectiveProtocols.allreduce.userect = 0; > } > else if(strncasecmp(envopts, "P", 1) == 0) /* CCMI Pipelined Tree */ > { > MPIDI_CollectiveProtocols.allreduce.usepipelinedtree = 1;// defaults to off > MPIDI_CollectiveProtocols.allreduce.usetree = 0; > MPIDI_CollectiveProtocols.allreduce.usebinom = 0; > MPIDI_CollectiveProtocols.allreduce.userect = 0; > } > else > fprintf(stderr,"Invalid DCMF_ALLREDUCE option\n"); > } > > envopts = getenv("DCMF_ALLREDUCE_REUSE_STORAGE"); > if(envopts != NULL) > { > if(strncasecmp(envopts, "N", 1) == 0) /* Do not reuse the malloc'd storage */ > { > MPIDI_CollectiveProtocols.allreduce.reusestorage = 0; > fprintf(stderr, "N allreduce.reusestorage %X\n", > MPIDI_CollectiveProtocols.allreduce.reusestorage); > } > else > if(strncasecmp(envopts, "Y", 1) == 0); /* defaults to Y */ > else > fprintf(stderr,"Invalid DCMF_ALLREDUCE_REUSE_STORAGE option\n"); > } > > envopts = getenv("DCMF_REDUCE"); > if(envopts != NULL) > { > if(strncasecmp(envopts, "M", 1) == 0) /* MPICH */ > { > MPIDI_CollectiveProtocols.reduce.usetree = 0; > MPIDI_CollectiveProtocols.reduce.userect = 0; > MPIDI_CollectiveProtocols.reduce.usebinom = 0; > MPIDI_CollectiveProtocols.optreduce = 0; > } > else if(strncasecmp(envopts, "RI", 2) == 0) /* Rectangle Ring*/ > { > MPIDI_CollectiveProtocols.reduce.userectring = 1;// defaults to off > MPIDI_CollectiveProtocols.reduce.userect = 0; > MPIDI_CollectiveProtocols.reduce.usetree = 0; > MPIDI_CollectiveProtocols.reduce.usebinom = 0; > } > else if(strncasecmp(envopts, "R", 1) == 0) /* Rectangle */ > { > MPIDI_CollectiveProtocols.reduce.usetree = 0; > MPIDI_CollectiveProtocols.reduce.usebinom = 0; > } > else if(strncasecmp(envopts, "B", 1) == 0) /* Binomial */ > { > MPIDI_CollectiveProtocols.reduce.usetree = 0; > MPIDI_CollectiveProtocols.reduce.userect = 0; > } > else if(strncasecmp(envopts, "T", 1) == 0) /* Tree */ > { > MPIDI_CollectiveProtocols.reduce.usebinom = 0; > MPIDI_CollectiveProtocols.reduce.userect = 0; > } > else if(strncasecmp(envopts, "C", 1) == 0) /* CCMI Tree */ > { > MPIDI_CollectiveProtocols.reduce.useccmitree = 1;// defaults to off > MPIDI_CollectiveProtocols.reduce.usetree = 0; > MPIDI_CollectiveProtocols.reduce.usebinom = 0; > MPIDI_CollectiveProtocols.reduce.userect = 0; > } > else > fprintf(stderr,"Invalid DCMF_REDUCE option\n"); > } > > envopts = getenv("DCMF_REDUCE_REUSE_STORAGE"); > if(envopts != NULL) > { > if(strncasecmp(envopts, "N", 1) == 0) /* Do not reuse the malloc'd storage */ > { > MPIDI_CollectiveProtocols.reduce.reusestorage = 0; > fprintf(stderr, "N protocol.reusestorage %X\n", > MPIDI_CollectiveProtocols.reduce.reusestorage); > } > else > if(strncasecmp(envopts, "Y", 1) == 0); /* defaults to Y */ > else > fprintf(stderr,"Invalid DCMF_REDUCE_REUSE_STORAGE option\n"); > } > > envopts = getenv("DCMF_BARRIER"); > if(envopts != NULL) > { > if(strncasecmp(envopts, "M", 1) == 0) /* MPICH */ > { > /* still need to register a barrier for DCMF collectives */ > MPIDI_CollectiveProtocols.barrier.usebinom = 1; > /* MPIDI_Coll_register changes this state for us */ > /* MPIDI_CollectiveProtocols.barrier.usegi = 1; */ > MPIDI_CollectiveProtocols.optbarrier = 0; > } > else if(strncasecmp(envopts, "B", 1) == 0) /* Binomial */ > { > MPIDI_CollectiveProtocols.barrier.usegi = 0; > } > else if(strncasecmp(envopts, "G", 1) == 0) /* GI */ > { > MPIDI_CollectiveProtocols.barrier.usebinom = 0; > } > else > fprintf(stderr,"Invalid DCMF_BARRIER option\n"); > } > > envopts = getenv("DCMF_LOCALBARRIER"); > if(envopts != NULL) > { > if(strncasecmp(envopts, "B", 1) == 0) /* Binomial */ > { > MPIDI_CollectiveProtocols.localbarrier.uselockbox = 0; > } > else if(strncasecmp(envopts, "L", 1) == 0) /* Lockbox */ > { > MPIDI_CollectiveProtocols.localbarrier.usebinom = 0; > } > else > fprintf(stderr,"Invalid DCMF_LOCALBARRIER option\n"); > } > } > > > unsigned * > MPIDI_Comm_worldranks_init(MPID_Comm *comm_ptr) > { > unsigned *worldranks = NULL; > int lrank, numprocs = comm_ptr->local_size; > > worldranks = comm_ptr->dcmf.worldranks; > if (worldranks == NULL) > { > worldranks = comm_ptr->dcmf.worldranks = MPIU_Malloc(numprocs * sizeof(int)); > MPID_assert(worldranks != NULL); > for (lrank = 0; lrank < numprocs; lrank++) > worldranks[lrank] = comm_ptr->vcr[lrank]->lpid; > } > > return worldranks; > } diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/comm/topo/Makefile.sm bgp-mpich2/src/mpid/dcmf/src/comm/topo/Makefile.sm 0a1,11 > SUBDIRS= . > INCLUDES = -I${master_top_srcdir}/src/include -I${top_builddir}/src/include > lib${MPILIBNAME}_a_SOURCES = mpid_topo.c \ > mpid_cart_map.c \ > mpid_dims_create.c \ > mpidi_cart_map_1d_snake.c \ > mpidi_cart_map_nofold.c \ > mpidi_cart_map_fold.c \ > mpidi_physical_cart.c \ > mpidi_virtual_cart.c \ > mpidi_dims_create.c diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/comm/topo/mpid_cart_map.c bgp-mpich2/src/mpid/dcmf/src/comm/topo/mpid_cart_map.c 0a1,70 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file src/comm/topo/mpid_cart_map.c > * \brief ??? > */ > > #include "mpid_topo.h" > > static int MPIDI_Cart_map_work( const MPID_Comm *comm_ptr, > int ndims, const int dims[], const int periods[], > int *newrank ) > { > int notdone = 1; > MPIDI_PhysicalCart *phy_cart = MPIDI_PhysicalCart_new(); > MPIDI_VirtualCart *vir_cart = MPIDI_VirtualCart_new(); > > if (MPIDI_PhysicalCart_init( phy_cart, comm_ptr )) > goto fn_fail; > if (ndims > phy_cart->ndims+1) > goto fn_fail; > if (ndims == phy_cart->ndims+1) > { > if (dims[ndims-1] == 1) > --ndims; > else > goto fn_fail; > } > > MPIDI_VirtualCart_init( vir_cart, ndims, dims ); > if (vir_cart->size > phy_cart->size) > goto fn_fail; > > /* try different algorithms, from simple to difficult */ > if (notdone && vir_cart->ndims == 1) > notdone = MPIDI_Cart_map_1D_snake( vir_cart, phy_cart, newrank ); > > if (notdone) > notdone = MPIDI_Cart_map_nofold( vir_cart, phy_cart, newrank ); > > if (notdone) > notdone = MPIDI_Cart_map_fold( vir_cart, phy_cart, newrank ); > > fn_fail: > MPIDI_VirtualCart_free( vir_cart ); > MPIDI_PhysicalCart_free( phy_cart ); > > return notdone; > } > > /* interface */ > int MPID_Cart_map( const MPID_Comm *comm_ptr, int ndims, const int dims[], const int periods[], int *newrank ) > { > int mpi_errno = MPI_SUCCESS; > > mpi_errno = MPIDI_Cart_map_work( comm_ptr, ndims, dims, periods, newrank ); > if (mpi_errno) > { > mpi_errno = MPIR_Cart_map( comm_ptr, ndims, dims, periods, newrank ); > /* puts("BAILING TO ** MPIR_Cart_map ** THAT'S BAD!"); */ > } > > return mpi_errno; > } diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/comm/topo/mpid_dims_create.c bgp-mpich2/src/mpid/dcmf/src/comm/topo/mpid_dims_create.c 0a1,29 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file src/comm/topo/mpid_dims_create.c > * \brief ??? > */ > > #include "mpid_topo.h" > > /** \brief Hook function for a torus-geometry optimized version of MPI_Dims_Create */ > int MPID_Dims_create( int nnodes, int ndims, int *dims ) > { > int mpi_errno = MPI_SUCCESS; > > mpi_errno = MPIDI_Dims_create_work( nnodes, ndims, dims ); > if (mpi_errno) > { > mpi_errno = MPIR_Dims_create( nnodes, ndims, dims ); > /* puts("BAILING TO ** MPIR_Dims_create ** THAT'S BAD!"); */ > } > > return mpi_errno; > } diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/comm/topo/mpidi_cart_map_1d_snake.c bgp-mpich2/src/mpid/dcmf/src/comm/topo/mpidi_cart_map_1d_snake.c 0a1,42 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file src/comm/topo/mpidi_cart_map_1d_snake.c > * \brief ??? > */ > > #include "mpid_topo.h" > > /* snake through the rectangular space following XYZT */ > int MPIDI_Cart_map_1D_snake( MPIDI_VirtualCart *vir_cart, > MPIDI_PhysicalCart *phy_cart, > int *newrank ) > { > int norm_coord; > int i, odd; > > if (vir_cart->size > phy_cart->size) return 1; > > *newrank = phy_cart->coord[0] - phy_cart->start[0]; > for (i=1; indims; i++) { > > norm_coord = phy_cart->coord[i] - phy_cart->start[i]; /* normalized coord */ > odd = *newrank % 2; /* odd or even */ > > *newrank *= phy_cart->dims[i]; > if (!odd) /* which way to count */ > *newrank += norm_coord; > else > *newrank += (phy_cart->dims[i] - 1 - norm_coord); > } > > if (*newrank >= vir_cart->size) *newrank = MPI_UNDEFINED; > > return 0; > } diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/comm/topo/mpidi_cart_map_fold.c bgp-mpich2/src/mpid/dcmf/src/comm/topo/mpidi_cart_map_fold.c 0a1,564 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file src/comm/topo/mpidi_cart_map_fold.c > * \brief ??? > */ > > #include "mpid_topo.h" > > /* finished = perm_next( ndims, perm_array[ndims] ) > gets the next permutation. It returns 1 when there is no next permutation. > For ndims = 3, the permutation sequence is > 0,1,2 --> 0,2,1 --> 1,0,2 --> 1,2,0 --> 2,0,1 --> 2,0,1 --> finished. > > */ > static int perm_next( int size, int inperm[] ) > { > int i, j, place, place1, temp; > > place1 = -1; > place = -1; > for (i=size-1; i>0; i--) > { > if (inperm[i] < inperm[i-1] && place1 == -1) place1 = i; > if (inperm[i] > inperm[i-1]) { place = i; break; } > } > > /* last in the permutation */ > if (place==-1) return 1; > > for (i=size-1; i>place; i--) > if (inperm[i] < inperm[i-1] && inperm[i] > inperm[place-1]) > { > place1 = i; break; > } > > /* long swap */ > if (place1 != -1 && inperm[place-1] < inperm[place1]) { > temp = inperm[place1]; > for (i=place1; i>=place; i--) inperm[i] = inperm[i-1]; > inperm[place-1] = temp; > } > > /* or short swap */ > else { > temp = inperm[place-1]; > inperm[place-1] = inperm[place]; > inperm[place] = temp; > } > > /* bubble sort the tail */ > for (i=place; i int action = 0; > for (j=place; j if (inperm[j] > inperm[j+1]) { > temp = inperm[j]; > inperm[j] = inperm[j+1]; > inperm[j+1] = temp; > action = 1; > } > } > if (!action) break; > } > > return 0; > } > > /* fail = find_fold( dims1[ndims1], dims2[ndims2], fold[3][3] ) > searchs a folding schedule, the folding schedule is stored in matrix fold[3][3] > e.g. fold[i][j] = 3 indicates to unfold dimension i onto dimension j. > fold[i][i] has no meaning. > For 3D case as here, there will be at most 2 non-zero, non-diagonal entries. > Diagonal entries are useless here. > Further more, when the 2 non-zero entries are in the same row, the virtual cartesian is > unfolded from the row_id dimension onto the other dimensions in physical cartesian. > when the 2 entries are in the same coloum, the virtual cartesian is actually > folded from the physical cartesian. > */ > static int find_fold( int nd1, int d1[], int nd2, int d2[], int fold[][3] ) > { > int neg_nfold=0, pos_nfold=0; > int neg_fold=1, pos_fold=1; > int i, j; > #if 0 > static int count=0; > #endif > > /* initialize matrix */ > for (i=0; i<3; i++) for (j=0; j<3; j++) fold[i][j] = 0; > > /* count requesting folds and folds can gives away. */ > for (i=0; i /* free folds */ > if (d1[i] < d2[i]) > { > fold[i][i] = d2[i]/d1[i]; /* floor () */ > pos_fold *= fold[i][i]; > pos_nfold ++; > } > else > /* needed folds */ > if (d1[i] > d2[i]) > { > fold[i][i] = -(d1[i]+d2[i]-1)/d2[i]; /* roof () */ > neg_fold *= (-fold[i][i]); > neg_nfold ++; > } > } > > /* always: physical ndims >= virtual ndims */ > for (i=nd1; i 1) { fold[i][i] = d2[i]; pos_fold *= fold[i][i]; pos_nfold ++; } > > /* requesting folds > available folds --> can not fold. */ > if (neg_fold > pos_fold) return 1; > > /* > Merge the negative folds and positive folds. For 3D case, there are following possible cases: > 0 dimension requests folds; > 1 dimension requests folds : must have 1 or 2 dimensions have free folds. > 2 dimensions requests folds: must have 1 dimension has free folds. > Previous test excludes cases that free folds are fewer than needing folds. > */ > > /* no fold is needed */ > if (!neg_nfold) { > for (i=0; i return 0; > } > else > /* only one dimension NEEDS folds from other 1/2 dimensions */ > if (neg_nfold == 1) { > > for (i=0; i if (fold[i][i] < 0) /* this is needy dimension */ > { > int ask = -fold[i][i]; /* now how many folds do you want */ > > for (j=0; j { > if (j==i) continue; > if (fold[j][j] > 0 && ask > 1) /* j dimension has some folds */ > { > /* j dimension can fully satisfy the left need */ > if (fold[j][j] >= ask) { > fold[j][i] = ask; > ask = 0; > } > /* j dimension can partially satisfy the left need */ > else > { > fold[j][i] = fold[j][j]; > ask = (ask + fold[j][j] -1) / fold[j][j]; /* roof () */ > } > } > } > > /* end of the try, still left some needs --> fail */ > if (ask > 1) return 1; > } > } > else > /* only one dimension can GIVE folds to other 1/2 dimensions */ > if (pos_nfold == 1) { > > for (i=0; i if (fold[i][i] > 0) /* this is the donor dimension */ > { > int has = fold[i][i]; /* how many folds can it give away */ > > for (j=0; j { > if (j==i) continue; > if (fold[j][j] < 0 && has > 1) /* j needs folds and i has some left */ > { > /* left free folds can satisfy j's request */ > if (-fold[j][j] <= has) { > fold[i][j] = -fold[j][j]; > has = has / (-fold[j][j]); > } > /* donor broken */ > else { > has = 0; break; > } > } > } > > /* end of the try, left deficit --> fail */ > if (has < 1) return 1; > } > } > > #if 0 > if (!count) { > printf( "\t\tfold 1 = " ); > for (i=0; i<3; i++) { for (j=0; j<3; j++) printf( "%4d", fold[i][j] ); printf( "; " ); } > printf( "\n" ); > } > count ++; > #endif > > return 0; > } > > /* Core of the whole folding story. > unfold dimension "dim_from" onto "dim_onto" in 3D setting. The coordinates on > dim_from (Z) and dim_onto (X) are both updated. The coordinate of the other > dimension (Y) does not change. > */ > static void unfold_3d( int pdims[3], int coord[3], int dim_from, int dim_onto, int folds ) > { > int layers = pdims[dim_from] / folds; > int fold_num = coord[dim_from] / layers; > int newz = coord[dim_from] % layers; > > if (fold_num % 2) /* reverse direction */ > { > coord[dim_onto] = fold_num * pdims[dim_onto] + (pdims[dim_onto]-1 - coord[dim_onto]); > coord[dim_from] = layers-1 - newz; > } > else /* same direction */ > { > coord[dim_onto] = fold_num * pdims[dim_onto] + coord[dim_onto]; > coord[dim_from] = newz; > } > > pdims[dim_from] /= folds; > pdims[dim_onto] *= folds; > } > > /* perform_fold( vir_coord[], phy_coord[], fold[3][3] ) > does the folding following the schedule given by fold[3][3]. > */ > static void perform_fold( int nd1, int d1[], int c1[], int nd2, int d2[], int c2[], int perm[], int fold[][3] ) > { > int i, j, nf, fold_list[9][3], t, dd2[3]; > > /* fold[][] has 2 useful entries out of 9. Then it is a sparse matrix, right? */ > nf = 0; > for (i=0; i<3; i++) > for (j=0; j<3; j++) > if (j!=i && fold[i][j] > 1) > { > fold_list[nf][0] = fold[i][j]; > fold_list[nf][1] = i; > fold_list[nf][2] = j; > nf ++; > } > > /* 3x3 case, nf is 0, 1, 2 */ > if (nf == 2) > { > /* When the 2 non-zero entries are in the same row, the virtual cartesian is > unfolded from the row_id dimension onto the other dimensions in physical cartesian. > Then UNFOLD the dimension with more folds first to reduce dialation. > */ > if (fold_list[0][1] == fold_list[1][1]) { > if (fold_list[0][0] < fold_list[1][0]) { > for (i=0; i<3; i++) { > t = fold_list[0][i]; > fold_list[0][i] = fold_list[1][i]; > fold_list[1][i] = t; > } > } > } > /* When the 2 entries are in the same coloum, the virtual cartesian is actually > folded from the physical cartesian. > Then FOLD the dimension with less folds first to reduce dialation. > */ > else { > if (fold_list[0][0] > fold_list[1][0]) { > for (i=0; i<3; i++) { > t = fold_list[0][i]; > fold_list[0][i] = fold_list[1][i]; > fold_list[1][i] = t; > } > } > } > > for (i=0; i<3; i++) c1[i] = c2[perm[i]]; > for (i=0; i<3; i++) dd2[i] = d2[perm[i]]; > unfold_3d( dd2, c1, fold_list[0][1], fold_list[0][2], fold_list[0][0] ); > unfold_3d( dd2, c1, fold_list[1][1], fold_list[1][2], fold_list[1][0] ); > } > > /* Z to X and Y stays the same, how nice, no dialation */ > if (nf == 1) > { > for (i=0; i<3; i++) c1[i] = c2[perm[i]]; > for (i=0; i<3; i++) dd2[i] = d2[perm[i]]; > unfold_3d( dd2, c1, fold_list[0][1], fold_list[0][2], fold_list[0][0] ); > } > > /* no fold, only permute the coordinate */ > if (nf == 0) > { > for (i=0; i<3; i++) c1[i] = c2[perm[i]]; > } > > return; > } > > /* Main control of the folding mapping. > 1. This routine only folds the 3 true dimensions. T dimension (if in virtual node mode) > is handled specifically in the caller of this routine. > 2. finished = perm_next( ndims, perm_array[ndims] ) > gets the next permutation. It returns 1 when there is no next permutation. > For ndims = 3, the permutation sequence is > 0,1,2 --> 0,2,1 --> 1,0,2 --> 1,2,0 --> 2,0,1 --> 2,0,1 --> finished. > 3. fail = find_fold( dims1[ndims1], dims2[ndims2], fold[3][3] ) > searchs a folding schedule, the folding schedule is stored in matrix fold[3][3] > e.g. fold[i][j] = 3 indicates to unfold dimension i onto dimension j. > fold[i][i] has no meaning. > For 3D case as here, there will be at most 2 non-zero, non-diagonal entries. > Diagonal entries are useless here. > Further more, when the 2 non-zero entries are in the same row, the virtual cartesian is > unfolded from the row_id dimension onto the other dimensions in physical cartesian. > when the 2 entries are in the same coloum, the virtual cartesian is actually > folded from the physical cartesian. > 4. perform_fold( vir_coord[], phy_coord[], fold[3][3] ) > does the folding following the schedule given by fold[3][3]. > */ > static int perm_dims_match( int nd1, int d1[], int c1[], int nd2, int d2[], int c2[] ) > { > int perm[3] = {0,1,2}; > int fold[3][3] = {{0,0,0}, {0,0,0}, {0,0,0}}; > int fail, finished; > int dd2[3], i; > > fail = 1; > finished = 0; > while( !finished ) > { > for (i=0; i<3; i++) dd2[i] = d2[perm[i]]; > fail = find_fold( nd1, d1, nd2, dd2, fold ); > if (!fail) { break; } > finished = perm_next( nd2, perm ); > } > > if (fail) return 1; > > perform_fold( nd1, d1, c1, nd2, d2, c2, perm, fold ); > > return 0; > } > > /* C_order means the right-most dimension is the fastest changing dimension. > Of course, dims[3] is on the right of dims[0]. The cart utilities routines > of MPICH2 follows this order; BG/L XYZT mapping following the reverse order > (Fortran order). > */ > void MPIDI_Cart_map_coord_to_rank( int size, int nd, int dims[], int cc[], int *newrank ) > { > int radix, i; > > *newrank = 0; radix = 1; > for (i=nd-1; i>=0; i--) > { > if (cc[i] >= dims[i]) { /* outside vir_cart box */ > *newrank = MPI_UNDEFINED; > break; > } > *newrank += cc[i] * radix; > radix *= dims[i]; > } > if (*newrank >= size) *newrank = MPI_UNDEFINED; > > return; > } > > /* Try to map arbitrary 2D-4D requests onto 3D/4D mesh (rectangular communicator). > > The basic idea is like to fold a paper in both dimension into a 3D mesh. There > do exist some edge loss when folding in both dimensions and therefore the mapping > dialation can be greater than 1. > > The core operator is defined in routine "unfold_3d" which unfolds dim_X onto dim_Z > with dim_Y unchanged. When starting from physical coordinates / dimensions, the operator > is transitive. i.e., one can do > unfold_3d( X, Z, dims[], coord[] ) > unfold_3d( X, Y, dims[], coord[] ) > And the dims[] and coord[] all changes to the new cartesian. > > Currently, limitation is only for 4D request. For 4D request, there has to be one dimension > with size 2 to match the T dimension. This is because I do not fully understand folding on > 4D cartesian. > */ > > int MPIDI_Cart_map_fold( MPIDI_VirtualCart *vir_cart, > MPIDI_PhysicalCart *phy_cart, > int *newrank ) > { > int notdone, i, j; > int c1[3], d1[3], c2[3], d2[3], cc[3]; > int vir_perm[4] = {0,1,2,3}; > int phy_perm[4] = {0,1,2,3}; > > /* sort dimension in decreasing order to hope reduce the number of foldings. */ > MPIDI_Cart_dims_sort( vir_cart->ndims, vir_cart->dims, vir_perm ); > MPIDI_Cart_dims_sort( 3, phy_cart->dims, phy_perm ); > > notdone = 1; > > /* covers case: > * 1. 4 = phy_cart->ndims > vir_cart->ndims > 1 > * solution: > * 1. try each vir_cart->dims[] > * 2. vir_cart->dims[i] = roof (vir_cart->dims[i] / 2); > * 3. try fold > * 4. coord[i] = coord[i] * 2 + cpu_id > */ > if (phy_cart->ndims==4 && vir_cart->ndims<4) > { > for (i=vir_cart->ndims-1; i>=0; i--) { > d1[i] = (vir_cart->dims[vir_perm[i]]+1)/2; > for (j=0; jndims; j++) if (j!=i) d1[j] = vir_cart->dims[vir_perm[j]]; > > for (j=0; j<3; j++) { > c2[j] = phy_cart->coord[phy_perm[j]] - phy_cart->start[phy_perm[j]]; > d2[j] = phy_cart->dims [phy_perm[j]]; > c1[j] = 0; > } > > if (perm_dims_match( vir_cart->ndims, d1, c1, 3, d2, c2 )) continue; > > for (j=0; j<3; j++) if (j!=i) cc[vir_perm[j]] = c1[j]; > cc[vir_perm[i]] = c1[i] * 2 + (phy_cart->coord[3] - phy_cart->start[3]); > notdone = 0; > break; > } > } > /* covers cases: > * 1. phy_cart->ndims == vir_cart->ndims == 4 > * solution: remove the T dimension from both phy and vir cartesian. Then this case > * becomes case 2. > * 2. 3 = phy_cart->ndims >= vir_cart->ndims > 1 > * solusion: just try fold. > * > */ > else > { > int vir_ndims = vir_cart->ndims; > > if (vir_ndims == 4) { > if (vir_cart->dims[vir_perm[3]] != 2) return 1; > vir_ndims = 3; > } > > for (j=0; jdims[vir_perm[j]]; > for (j=0; j<3; j++) { > c2[j] = phy_cart->coord[phy_perm[j]] - phy_cart->start[phy_perm[j]]; > d2[j] = phy_cart->dims [phy_perm[j]]; > c1[j] = 0; > } > > if (!perm_dims_match( vir_ndims, d1, c1, phy_cart->ndims, d2, c2 )) { > for (j=0; j<3; j++) cc[vir_perm[j]] = c1[j]; > notdone = 0; > } > } > > if (notdone) return notdone; > > /* C_order means the right-most dimension is the fastest changing dimension. > Of course, dims[3] is on the right of dims[0]. The cart utilities routines > of MPICH2 follows this order; BG/L XYZT mapping following the reverse order > (Fortran order). > */ > MPIDI_Cart_map_coord_to_rank( vir_cart->size, vir_cart->ndims, vir_cart->dims, cc, newrank ); > > /* > printf( "\t<%2d,%2d,%2d,%2d> to %4d (notdone = %d)\n", > phy_cart->coord[0], > phy_cart->coord[1], > phy_cart->coord[2], > phy_cart->coord[3], > *newrank, > notdone ); > */ > > return notdone; > } > > > /* > int main( int argc, char *argv[] ) > { > int perm[5] = {0,1,2,3,4}, next=0, cnt = 0, i, size=4; > int fold[3][3]; > int ret, c2[3], c1[3]; > > // int n1=450, nd1=3, d1[3] = {15,15,2}; > // int n2=512, nd2=3, d2[3] = {8,8,8}; > > // int n1=343, nd1=3, d1[3] = {7,7,7}; > // int n2=512, nd2=3, d2[3] = {16,16,2}; > > // int n1=343, nd1=3, d1[3] = {7,7,7}; > // int n2=512, nd2=3, d2[3] = {64,4,2}; > > // int n1=465, nd1=2, d1[3] = {31,15}; > // int n2=512, nd2=3, d2[3] = {64,4,2}; > > int n1=49, nd1=2, d1[3] = {3,5,1}; > int n2=64, nd2=3, d2[3] = {2,2,6}; > > for (c2[0]=0; c2[0] for (c2[1]=0; c2[1] { > for (c2[2]=0; c2[2] { > ret = perm_dims_match( nd1, d1, c1, nd2, d2, c2 ); > // printf( "ret = %d\n", ret ); > printf( "<%2d/%2d,%2d/%2d,%2d/%2d> to <%2d/%2d,%2d/%2d,%2d/%2d>\n", > c2[0], d2[0], > c2[1], d2[1], > c2[2], d2[2], > c1[0], d1[0], > c1[1], d1[1], > c1[2], d1[2] > ); > // cnt ++; > // if (cnt > 10) return 0; > } > printf( "\n" ); > } > > return 0; > } > */ > > /* > int main( int argc, char *argv[] ) > { > int perm[5] = {0,1,2,3,4}, next=0, cnt = 0, i, size=4; > int fold[3][3]; > int ret; > > // int n1=450, nd1=3, d1[3] = {15,15,2}; > // int n2=512, nd2=3, d2[3] = {8,8,8}; > > // int n1=343, nd1=3, d1[3] = {7,7,7}; > // int n2=512, nd2=3, d2[3] = {16,16,2}; > > // int n1=343, nd1=3, d1[3] = {7,7,7}; > // int n2=512, nd2=3, d2[3] = {64,4,2}; > > // int n1=465, nd1=2, d1[3] = {31,15}; > // int n2=512, nd2=3, d2[3] = {64,4,2}; > > int n1=465, nd1=2, d1[3] = {31,15}; > int n2=512, nd2=3, d2[3] = {64,8,1}; > > ret = find_fold( nd1, d1, nd2, d2, fold ); > printf( "ret = %d\n", ret ); > > return 0; > } > */ diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/comm/topo/mpidi_cart_map_nofold.c bgp-mpich2/src/mpid/dcmf/src/comm/topo/mpidi_cart_map_nofold.c 0a1,135 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file src/comm/topo/mpidi_cart_map_nofold.c > * \brief ??? > */ > > #include "mpid_topo.h" > > static int try_permute_match( int *vir_cart, > int *phy_cart, > int nd_sort, int vir_perm[], int phy_perm[] ) > { > int nomatch, i; > > /* sort the dimensions of both cart in decreasing order, keeps order in _perm arrays */ > MPIDI_Cart_dims_sort( nd_sort, vir_cart, vir_perm ); > MPIDI_Cart_dims_sort( nd_sort, phy_cart, phy_perm ); > > nomatch = 0; > for (i=0; i if (vir_cart[vir_perm[i]] > phy_cart[phy_perm[i]]) { nomatch = 1; break; } > } > return nomatch; > } > > /* non-1D exact match: > 1. when req and phy are both 4D: permut-match. > 2. phy is 4D and req is 2D or 3D: find a req dimension to embed the T dimension. > Then do a permute-match excluding T in both req and phy dimensions. > 3. phy is 3D and req is 2D or 3D: permute-match with req empty dimension (if exists) filled with 1. > */ > int MPIDI_Cart_map_nofold( MPIDI_VirtualCart *vir_cart, > MPIDI_PhysicalCart *phy_cart, > int *newrank ) > { > int phy_perm[DCMF_CART_MAX_NDIMS]; > int vir_perm[DCMF_CART_MAX_NDIMS]; > int thedim = -1; > > int i, rcoord[DCMF_CART_MAX_NDIMS]; > int permute_match; > int notdone = 1; > > if (vir_cart->ndims <= 3 && phy_cart->ndims == 4) { > > for (i=vir_cart->ndims; i > notdone = 1; > > /* look for an exact inclusion */ > if (vir_cart->size < phy_cart->size) { > if( try_permute_match( vir_cart->dims, phy_cart->dims, phy_cart->ndims, vir_perm, phy_perm ) ) { > } > else { > /* permute the 4 coordinates */ > for (i=0; indims; i++) > rcoord[ vir_perm[i] ] = phy_cart->coord[ phy_perm[i] ] - phy_cart->start[ phy_perm[i] ]; > notdone = 0; > } > } > > if (notdone) { > /* now try embed T into requested dimensions */ > int orig_dim; > for (i=phy_cart->ndims-1; i>=1; i--) { > orig_dim = phy_cart->dims[i]; > phy_cart->dims[i] *= phy_cart->dims[0]; > permute_match = try_permute_match( vir_cart->dims, phy_cart->dims+1, vir_cart->ndims, vir_perm, phy_perm ); > phy_cart->dims[i] = orig_dim; > if (!permute_match) break; > } > --i; > if (i < 0) return 1; > > /* the dimension that contains the T */ > thedim = i; > > /* permute the 3 coordinates */ > { > int temp[DCMF_CART_MAX_NDIMS]; > for (i=0; indims; i++) > temp[ i ] = phy_cart->coord[ i+1 ] - phy_cart->start[ i+1 ]; > /* fill the T dimension in here */ > temp[ thedim ] = temp[ thedim ] * phy_cart->dims[0] + (phy_cart->coord[0] - phy_cart->start[0]); > for (i=0; indims; i++) > rcoord[ vir_perm[i] ] = temp[ phy_perm[i] ]; > } > } > } > else > if (vir_cart->ndims == 4 && phy_cart->ndims ==4) { > if( try_permute_match( vir_cart->dims, phy_cart->dims, phy_cart->ndims, vir_perm, phy_perm ) ) return 1; > > /* permute the 4 coordinates */ > for (i=0; indims; i++) > rcoord[ vir_perm[i] ] = phy_cart->coord[ phy_perm[i] ] - phy_cart->start[ phy_perm[i] ]; > } > else > if (vir_cart->ndims <= 3 && phy_cart->ndims == 3) { > for (i=vir_cart->ndims; i > if( try_permute_match( vir_cart->dims, phy_cart->dims, 3, vir_perm, phy_perm ) ) return 1; > > /* permute the 3 coordinates */ > for (i=0; indims; i++) > rcoord[ vir_perm[i] ] = phy_cart->coord[ phy_perm[i] ] - phy_cart->start[ phy_perm[i] ]; > } > else return 1; > > MPIDI_Cart_map_coord_to_rank( vir_cart->size, 4, vir_cart->dims, rcoord, newrank ); > > #if 0 > printf( "<" ); > for (i=0;indims;i++) { > printf( "%d/%d", phy_cart->coord[i], phy_cart->dims[i] ); > if (i != phy_cart->ndims-1) printf( "," ); > } > printf( "> to <" ); > for (i=0;indims;i++) { > printf( "%d/%d", rcoord[i], vir_cart->dims[i] ); > if (i != phy_cart->ndims-1) printf( "," ); > } > printf( ">, r=%d\n", *newrank ); > #endif > > > return 0; > } diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/comm/topo/mpidi_dims_create.c bgp-mpich2/src/mpid/dcmf/src/comm/topo/mpidi_dims_create.c 0a1,203 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file src/comm/topo/mpidi_dims_create.c > * \brief ??? > */ > > #include "mpid_topo.h" > > static int compare (const void * ap, const void *bp) > { > register int a = *(int*)ap; > register int b = *(int*)bp; > register int result = 0; > if (a result = 1; > else if (a>b) > result = -1; > > return result; > } > > /* > * With the possibly partial dimension request, return dims[3] as a permutation of phy_dims[3]. > * Function returns 0 when a match found; returns 1 when not found. > */ > static int permute_match( int ndims, const int phy_dims[], int *dims ) { > int phy_done[4] = {0,0,0,0}; > int nomatch, i, j; > > /* match the filled-dimensions of the request with physical dimensions. */ > for (i=ndims-1; i>=0; i--) { > if ( dims[i] <= 0 ) continue; > nomatch = 1; > for (j=ndims-1; j>=0; j--) { > if ( phy_done[j] ) continue; > if ( dims[i] == phy_dims[j] ) { phy_done[j] = 1; nomatch = 0; break; } > } > if ( nomatch ) return 1; > } > > /* fill the empty-dimensions of the request with not used physical dimensions */ > for (i=0; i if ( dims[i] > 0 ) continue; > for (j=0; j if ( !phy_done[j] ) { dims[i] = phy_dims[j]; phy_done[j] = 1; break; } > } > > return 0; > } > > /* non-1D exact match: > 1. when req and phy are both 4D: permut-match. > 2. phy is 4D and req is 2D or 3D: find a req dimension to embed the T dimension. > Then do a permute-match excluding T in both req and phy dimensions. > 3. phy is 3D and req is 2D or 3D: permute-match with req empty dimension (if exists) filled with 1. > > For many cases, returned NOTDONE, because the MPICH2 default implementation has a fancy factorization > algorithm which can generate fairly squared cartesian dimensions. > > In addition, since MPI_Dims_create() does not has communicator associated to it. Only implementation is > to map to MPI_COMM_WORLD, which is most time sqaured cartesian in XYZ dimensions. > > So, the default implementation can work pretty well. Here, only to work the permutation right. > */ > int MPIDI_Dims_create_nofold( MPIDI_VirtualCart *vir_cart, > MPIDI_PhysicalCart *phy_cart ) > { > if (vir_cart->ndims < 3) return 1; > if (vir_cart->size != phy_cart->size) return 1; > > if (phy_cart->ndims == 4) > { > if (vir_cart->ndims == 4) > return permute_match( 4, phy_cart->dims, vir_cart->dims ); > else if (vir_cart->ndims == 3) > { > int i, error = 0; > int vir_dims[4]; > int phy_dims[4]; > phy_dims[0] = phy_cart->dims[1]; > phy_dims[1] = phy_cart->dims[2]; > phy_dims[2] = phy_cart->dims[3]; > for (i=0; i<3; i++) { > phy_dims[i] *= phy_cart->dims[0]; > vir_dims[0] = vir_cart->dims[0]; > vir_dims[1] = vir_cart->dims[1]; > vir_dims[2] = vir_cart->dims[2]; > error = permute_match( 3, phy_dims, vir_dims ); > if (!error) break; > phy_dims[i] = phy_cart->dims[i+1]; > } > if (!error) > { > vir_cart->dims[0] = vir_dims[0]; > vir_cart->dims[1] = vir_dims[1]; > vir_cart->dims[2] = vir_dims[2]; > return 0; > } > } > } > else if (phy_cart->ndims == 3) > { > if (vir_cart->ndims == 4) > { > vir_cart->dims[DCMF_CART_MAX_NDIMS-1] = 1; > return permute_match(3, phy_cart->dims, vir_cart->dims); > } > else if (vir_cart->ndims == 3) > return permute_match(3, phy_cart->dims, vir_cart->dims); > } > > return 1; > } > > /* > * First implementation, only effect when the query request fits in the dimensionality of the partition: > * condition 1: ndims = 3i > * condition 2: non-zero dims[] entries matches the dimensionality of the partition. > */ > int MPIDI_Dims_create_work( int nnodes, int ndims, int *dims ) > { > > int notdone = 1; > MPIDI_PhysicalCart *phy_cart; > MPIDI_VirtualCart *vir_cart; > int periods[4] = {0,0,0,0}; > MPID_Comm *comm_ptr = MPIR_Process.comm_world; > int set_cnt, node_cnt, empty_dim, i; > > set_cnt = 0; > node_cnt = 1; > empty_dim = -1; > if (ndims < 1) return MPI_ERR_ARG; > if (nnodes < 1) return MPI_ERR_ARG; > for (i=0; i if (dims[i] > 0) { > set_cnt++; node_cnt *= dims[i]; > } else if (dims[i] == 0) { > empty_dim = i; > } else { > return MPI_ERR_DIMS; > } > } > > if ((nnodes / node_cnt) * node_cnt != nnodes ) return MPI_ERR_DIMS; > if (set_cnt == ndims) return 0; > if (set_cnt == ndims-1) { > dims[empty_dim] = nnodes/node_cnt; > return 0; > } > > /* now dealing case: > dims[2] = {0,0} > when nnodes == phy_size, default factorization can do the trick for folding case. > dims[3] = {0,0,?} > when nodes == phy_size, default factorization can do the trick for general case for folding. > dims[4] = {0,0,?,?} > has to be exact match. > > */ > > phy_cart = MPIDI_PhysicalCart_new(); > vir_cart = MPIDI_VirtualCart_new(); > > if (MPIDI_PhysicalCart_init( phy_cart, comm_ptr )) goto fn_return; > if (ndims > DCMF_CART_MAX_NDIMS) goto fn_return; > if (nnodes > phy_cart->size ) goto fn_return; > > MPIDI_VirtualCart_init( vir_cart, ndims, dims); > vir_cart->size = nnodes; > vir_cart->ndims = ndims; > for(i=0; i vir_cart->dims[i] = dims[i]; > > notdone = MPIDI_Dims_create_nofold( vir_cart, phy_cart ); > > /* return computed dimensions */ > if (!notdone) > { > int i,j; > int sort_dims[ndims]; > for (j=i=0; i if (dims[i] == 0) > sort_dims[j++] = vir_cart->dims[i]; > qsort(sort_dims, j, sizeof(int), compare); > for (j=i=0; i if (dims[i] == 0) > dims[i] = sort_dims[j++]; > } > > fn_return: > MPIDI_VirtualCart_free( vir_cart); > MPIDI_PhysicalCart_free(phy_cart); > > return notdone; > } diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/comm/topo/mpidi_physical_cart.c bgp-mpich2/src/mpid/dcmf/src/comm/topo/mpidi_physical_cart.c 0a1,128 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file src/comm/topo/mpidi_physical_cart.c > * \brief ??? > */ > > #include "mpid_topo.h" > #include "mpix.h" > > > MPIDI_PhysicalCart *MPIDI_PhysicalCart_new() > { > return (MPIDI_PhysicalCart *) MPIU_Malloc ( sizeof(MPIDI_PhysicalCart) ); > } > > void MPIDI_PhysicalCart_free( MPIDI_PhysicalCart *cart ) > { > if (cart != NULL) MPIU_Free (cart); > } > > /* To verify whether the given communicator is a rectangular communicator. > > Copied from mpid/bgltorus5/src/coll/mpid_collective.c:MPIDI_BGLTS_findRect(). > The reason for not using using comm->bglts.rectcomm is NOT valid: was not sure > whether every communicator tried to construct the comm->bglts.rectcomm. > > Can go further: give existing BG/L Z major ranking. for a non-rectangular communicator, > it is likely to find maximal cartesian partition without using the convex-hull algo. > */ > static int MPIDI_PhysicalCart_checkRect(const MPID_Comm *comm, int minc[], int maxc[] ) > { > int i, j, size; > unsigned c[4]; > > for (j=0; j<4; j++) { > minc[j] = MAXINT; maxc[j] = 0; > } > > for (i=0; i< comm->local_size; i++) > { > MPIX_rank2torus(comm->vcr[i]->lpid, &c[3], &c[2], &c[1], &c[0]); > for (j=0; j<4; j++) { > if (c[j] < minc[j]) minc[j] = c[j]; > if (c[j] > maxc[j]) maxc[j] = c[j]; > } > } > > size = 1; > for (j=0; j<4; j++) size *= (maxc[j]-minc[j]+1); > if (size != comm->local_size) return 1; > > return 0; > } > > /* For a rectangular communicator, initialize the MPIDI_PhysicalCart object with > dimension sizes and physical coordinates. > > For non rectangular communicator, return fail. > */ > int MPIDI_PhysicalCart_init( MPIDI_PhysicalCart *cart, const MPID_Comm *comm ) > { > > int j; > int minc[4], maxc[4]; > > MPID_assert (cart != NULL); > > if ( MPIDI_PhysicalCart_checkRect( comm, minc, maxc ) ) > return 1; > > for (j=0; j<4; j++) { > cart->start[j] = minc[j]; > cart->dims [j] = maxc[j] - minc[j] + 1; > } > > cart->coord[0] = mpid_hw.tCoord; > cart->coord[1] = mpid_hw.zCoord; > cart->coord[2] = mpid_hw.yCoord; > cart->coord[3] = mpid_hw.xCoord; > > for (j=0; j<4; j++) { > MPID_assert ( cart->coord[j] >= cart->start[j] ); > MPID_assert ( cart->coord[j] < cart->start[j] + cart->dims[j] ); > } > > cart->size = comm->local_size; > if (cart->dims[0] == 1) > { > cart->ndims = 3; > for (j=1; j cart->start [j-1] = cart->start [j]; > cart->dims [j-1] = cart->dims [j]; > cart->coord [j-1] = cart->coord [j]; > } > cart->start [j-1] = 0; > cart->dims [j-1] = 0; > cart->coord [j-1] = 0; > } > else > cart->ndims = 4; > > return 0; > } > > > void MPIDI_PhysicalCart_printf( MPIDI_PhysicalCart *c ) > { > printf("PhysicalCart(%p), size=%d, ndims=%d\n", c, c->size, c->ndims); > if (c->ndims == 4) > { > printf(" p dims =<%d,%d,%d,%d>\n",c->dims[0], c->dims[1], c->dims[2], c->dims[3] ); > printf(" p coord =<%d,%d,%d,%d>\n",c->coord[0], c->coord[1], c->coord[2], c->coord[3] ); > printf(" p start =<%d,%d,%d,%d>\n",c->start[0], c->start[1], c->start[2], c->start[3] ); > } > else > { > printf(" p dims =<%d,%d,%d>\n",c->dims[0], c->dims[1], c->dims[2] ); > printf(" p coord =<%d,%d,%d>\n",c->coord[0], c->coord[1], c->coord[2] ); > printf(" p start =<%d,%d,%d>\n",c->start[0], c->start[1], c->start[2] ); > } > } diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/comm/topo/mpidi_virtual_cart.c bgp-mpich2/src/mpid/dcmf/src/comm/topo/mpidi_virtual_cart.c 0a1,81 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file src/comm/topo/mpidi_virtual_cart.c > * \brief ??? > */ > > #include "mpid_topo.h" > > MPIDI_VirtualCart *MPIDI_VirtualCart_new() > { > return (MPIDI_VirtualCart *) MPIU_Malloc ( sizeof(MPIDI_VirtualCart) ); > } > > void MPIDI_VirtualCart_free( MPIDI_VirtualCart *cart ) > { > if (cart != NULL) MPIU_Free (cart); > } > > int MPIDI_VirtualCart_init( MPIDI_VirtualCart *cart, int ndims, const int dims[] ) > { > int i; > > /* kick out the dimensions having size 1 */ > cart->size = 1; > cart->ndims = 0; > for (i=0; i if (dims[i] > 1) { > cart->dims [cart->ndims] = dims[i]; > cart->size *= dims[i]; > cart->ndims ++; > } > } > > /* fill the garbage space with useful thing */ > for (i=cart->ndims; i<4; i++) { > cart->dims[i] = 1; > } > > return 0; > } > > /* bubble sort the dimension in decreasing order via a perm array */ > void MPIDI_Cart_dims_sort( int ndims, int dims[], int perm[] ) > { > int i, j, temp; > > for (i=0; i<4; i++) perm[i] = i; > for (i=0; i int action = 0; > for (j=0; j if (dims[perm[j]] < dims[perm[j+1]]) { > temp = perm[j]; > perm[j] = perm[j+1]; > perm[j+1] = temp; > action = 1; > } > } > if (!action) break; > } > } > > > void MPIDI_VirtualCart_printf( MPIDI_VirtualCart *c ) > { > printf("VirtualCart(%p), size=%d, ndims=%d\n", c, c->size, c->ndims); > if (c->ndims == 4) > { > printf(" v dims =<%d,%d,%d,%d>\n",c->dims[0], c->dims[1], c->dims[2], c->dims[3] ); > } > else > { > printf(" v dims =<%d,%d,%d>\n",c->dims[0], c->dims[1], c->dims[2] ); > } > } diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/comm/topo/mpid_topo.c bgp-mpich2/src/mpid/dcmf/src/comm/topo/mpid_topo.c 0a1,46 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file src/comm/topo/mpid_topo.c > * \brief Topology setup > */ > > #include "mpid_topo.h" > > /** > * \brief Hook function to handle topology-specific optimization during communicator creation > */ > void MPIDI_Topo_Comm_create (MPID_Comm *comm) > { > MPID_assert (comm!= NULL); > if (comm->topo_fns) MPIU_Free(comm->topo_fns); > comm->topo_fns=NULL; > > /* User may disable all topology optimizations */ > if (!MPIDI_Process.optimized.topology) return; > > /* ****************************************** */ > /* Allocate space for the topology pointers */ > /* ****************************************** */ > comm->topo_fns = (MPID_TopoOps *)MPIU_Malloc(sizeof(MPID_TopoOps)); > MPID_assert (comm->topo_fns != NULL); > memset (comm->topo_fns, 0, sizeof(MPID_TopoOps)); > comm->topo_fns->cartMap = MPID_Cart_map; > } > > /** > * \brief Hook function to handle topology-specific optimization during communicator destruction > * \note We want to free the associated topo_fns buffer at this time. > */ > void MPIDI_Topo_Comm_destroy (MPID_Comm *comm) > { > MPID_assert (comm != NULL); > if (comm->topo_fns) MPIU_Free(comm->topo_fns); > comm->topo_fns = NULL; > } diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/comm/topo/mpid_topo.h bgp-mpich2/src/mpid/dcmf/src/comm/topo/mpid_topo.h 0a1,87 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file src/comm/topo/mpid_topo.h > * \brief ??? > */ > #ifndef __mpidi_topo_h__ > #define __mpidi_topo_h__ > > #include > #include > #include > #include "mpidimpl.h" > #include "../mpi/topo/topo.h" > > #define DCMF_CART_MAX_NDIMS 4 > > > int MPID_Cart_map( const MPID_Comm *comm_ptr, int ndims, const int dims[], const int periods[], int *newrank ); > > > /* descriptor of physical cart topology and its methods */ > typedef struct MPIDI_PhysicalCart_s > { > int size; > int ndims; /* 3 or 4 */ > int start [DCMF_CART_MAX_NDIMS]; > int dims [DCMF_CART_MAX_NDIMS]; > int coord [DCMF_CART_MAX_NDIMS]; > > } MPIDI_PhysicalCart; > > MPIDI_PhysicalCart * MPIDI_PhysicalCart_new(); > void MPIDI_PhysicalCart_free( MPIDI_PhysicalCart *cart ); > int MPIDI_PhysicalCart_init( MPIDI_PhysicalCart *cart, const MPID_Comm *comm ); > > > /* descriptor of physical cart topology and its methods */ > typedef struct MPIDI_VirtualCart_s > { > int size; > int ndims; > int dims [DCMF_CART_MAX_NDIMS]; > > } MPIDI_VirtualCart; > > MPIDI_VirtualCart * MPIDI_VirtualCart_new(); > void MPIDI_VirtualCart_free( MPIDI_VirtualCart *cart ); > int MPIDI_VirtualCart_init( MPIDI_VirtualCart *cart, int ndims, const int dims[] ); > > /* utilities */ > void MPIDI_Cart_dims_sort( int ndims, int dims[], int perm[] ); > > /* C_order means the right-most dimension is the fastest changing dimension. > Of course, dims[3] is on the right of dims[0]. The cart utilities routines > of MPICH2 follows this order; BG/L XYZT mapping following the reverse order > (Fortran order). in mpidi_cart_map_fold.c > */ > void MPIDI_Cart_map_coord_to_rank( int size, int nd, int dims[], int cc[], int *newrank ); > > > /* working horse */ > int MPIDI_Cart_map_fold( MPIDI_VirtualCart *vir_cart, > MPIDI_PhysicalCart *phy_cart, > int *newrank ); > > int MPIDI_Cart_map_nofold( MPIDI_VirtualCart *vir_cart, > MPIDI_PhysicalCart *phy_cart, > int *newrank ); > > int MPIDI_Cart_map_1D_snake( MPIDI_VirtualCart *vir_cart, > MPIDI_PhysicalCart *phy_cart, > int *newrank ); > > int MPIDI_Dims_create_work ( int nnodes, int ndims, int *dims ); > int MPIDI_Dims_create_nofold( MPIDI_VirtualCart *vir_cart, MPIDI_PhysicalCart *phy_cart ); > > void MPIDI_PhysicalCart_printf( MPIDI_PhysicalCart *c ); > void MPIDI_VirtualCart_printf( MPIDI_VirtualCart *c ); > > #endif /* __mpidi_topo_h__ */ diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/impl/Makefile.sm bgp-mpich2/src/mpid/dcmf/src/impl/Makefile.sm 0a1,3 > SUBDIRS= . > INCLUDES = -I${master_top_srcdir}/src/include -I${top_builddir}/src/include > lib${MPILIBNAME}_a_SOURCES = mpid_buffer.c mpid_recvq.c mpid_request.c mpid_statistics.c diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/impl/mpid_buffer.c bgp-mpich2/src/mpid/dcmf/src/impl/mpid_buffer.c 0a1,200 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file src/impl/mpid_buffer.c > * \brief MPID buffer copy > */ > /* -*- Mode: C; c-basic-offset:4 ; -*- */ > /* > * (C) 2001 by Argonne National Laboratory. > * See COPYRIGHT in top-level directory. > */ > > #include "mpidimpl.h" > > #if !defined(MPIDI_COPY_BUFFER_SZ) > #define MPIDI_COPY_BUFFER_SZ 16384 > #endif > > /** > * \brief MPID buffer copy > * > * Implements non-contiguous buffers correctly. > * > * \param[in] sbuf The address of the input buffer > * \param[in] scount The number of elements in that buffer > * \param[in] sdt The datatype of those elements > * \param[out] smpi_errno Returns errors > * \param[in] rbuf The address of the output buffer > * \param[out] rcount The number of elements in that buffer > * \param[in] rdt The datatype of those elements > * \param[out] rsz The size of the ouput data > * \param[out] rmpi_errno Returns errors > */ > void MPIDI_DCMF_Buffer_copy( > const void * const sbuf, int scount, MPI_Datatype sdt, int * smpi_errno, > void * const rbuf, int rcount, MPI_Datatype rdt, MPIDI_msg_sz_t * rsz, > int * rmpi_errno) > { > int sdt_contig; > int rdt_contig; > MPI_Aint sdt_true_lb, rdt_true_lb; > MPIDI_msg_sz_t sdata_sz; > MPIDI_msg_sz_t rdata_sz; > MPID_Datatype * sdt_ptr; > MPID_Datatype * rdt_ptr; > > *smpi_errno = MPI_SUCCESS; > *rmpi_errno = MPI_SUCCESS; > > > // printf ("bufcopy: src count=%d dt =%d\n", scount, sdt); > // printf ("bufcopy: dst count=%d dt=%d\n", rcount, rdt); > > MPIDI_Datatype_get_info(scount, sdt, sdt_contig, sdata_sz, sdt_ptr, sdt_true_lb); > MPIDI_Datatype_get_info(rcount, rdt, rdt_contig, rdata_sz, rdt_ptr, rdt_true_lb); > > /* --BEGIN ERROR HANDLING-- */ > if (sdata_sz > rdata_sz) > { > sdata_sz = rdata_sz; > *rmpi_errno = MPIR_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, "MPIDI_DCMF_Buffer_copy", __LINE__, MPI_ERR_TRUNCATE, "**truncate", "**truncate %d %d", sdata_sz, rdata_sz ); > } > /* --END ERROR HANDLING-- */ > > if (sdata_sz == 0) > { > *rsz = 0; > goto fn_exit; > } > > if (sdt_contig && rdt_contig) > { > memcpy((char *)rbuf + rdt_true_lb, (const char *)sbuf + sdt_true_lb, sdata_sz); > *rsz = sdata_sz; > } > else if (sdt_contig) > { > MPID_Segment seg; > DLOOP_Offset last; > > MPID_Segment_init(rbuf, rcount, rdt, &seg, 0); > last = sdata_sz; > MPID_Segment_unpack(&seg, 0, &last, (char*)sbuf + sdt_true_lb); > /* --BEGIN ERROR HANDLING-- */ > if (last != sdata_sz) > { > *rmpi_errno = MPIR_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, "MPIDI_DCMF_Buffer_copy", __LINE__, MPI_ERR_TYPE, "**dtypemismatch", 0); > } > /* --END ERROR HANDLING-- */ > > *rsz = last; > } > else if (rdt_contig) > { > MPID_Segment seg; > DLOOP_Offset last; > > MPID_Segment_init(sbuf, scount, sdt, &seg, 0); > last = sdata_sz; > MPID_Segment_pack(&seg, 0, &last, (char*)rbuf + rdt_true_lb); > /* --BEGIN ERROR HANDLING-- */ > if (last != sdata_sz) > { > *rmpi_errno = MPIR_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, "MPIDI_DCMF_Buffer_copy", __LINE__, MPI_ERR_TYPE, "**dtypemismatch", 0); > } > /* --END ERROR HANDLING-- */ > > *rsz = last; > } > else > { > char * buf; > MPIDI_msg_sz_t buf_off; > MPID_Segment sseg; > MPIDI_msg_sz_t sfirst; > MPID_Segment rseg; > MPIDI_msg_sz_t rfirst; > > buf = MPIU_Malloc(MPIDI_COPY_BUFFER_SZ); > /* --BEGIN ERROR HANDLING-- */ > if (buf == NULL) > { > *smpi_errno = MPIR_Err_create_code(MPI_SUCCESS, MPIR_ERR_FATAL, "MPIDI_DCMF_Buffer_copy", __LINE__, MPI_ERR_OTHER, "**nomem", 0); > *rmpi_errno = *smpi_errno; > *rsz = 0; > goto fn_exit; > } > /* --END ERROR HANDLING-- */ > > MPID_Segment_init(sbuf, scount, sdt, &sseg, 0); > MPID_Segment_init(rbuf, rcount, rdt, &rseg, 0); > > sfirst = 0; > rfirst = 0; > buf_off = 0; > > for(;;) > { > DLOOP_Offset last; > char * buf_end; > > if (sdata_sz - sfirst > MPIDI_COPY_BUFFER_SZ - buf_off) > { > last = sfirst + (MPIDI_COPY_BUFFER_SZ - buf_off); > } > else > { > last = sdata_sz; > } > > MPID_Segment_pack(&sseg, sfirst, &last, buf + buf_off); > /* --BEGIN ERROR HANDLING-- */ > MPID_assert(last > sfirst); > /* --END ERROR HANDLING-- */ > > buf_end = buf + buf_off + (last - sfirst); > sfirst = last; > > MPID_Segment_unpack(&rseg, rfirst, &last, buf); > /* --BEGIN ERROR HANDLING-- */ > MPID_assert(last > rfirst); > /* --END ERROR HANDLING-- */ > > rfirst = last; > > if (rfirst == sdata_sz) > { > /* successful completion */ > break; > } > > /* --BEGIN ERROR HANDLING-- */ > if (sfirst == sdata_sz) > { > /* datatype mismatch -- remaining bytes could not be unpacked */ > *rmpi_errno = MPIR_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, "MPIDI_DCMF_Buffer_copy", __LINE__, MPI_ERR_TYPE, "**dtypemismatch", 0); > break; > } > /* --END ERROR HANDLING-- */ > > buf_off = sfirst - rfirst; > if (buf_off > 0) > { > memmove(buf, buf_end - buf_off, buf_off); > } > } > > *rsz = rfirst; > MPIU_Free(buf); > } > > fn_exit: > return; > } diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/impl/mpid_recvq.c bgp-mpich2/src/mpid/dcmf/src/impl/mpid_recvq.c 0a1,653 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file src/impl/mpid_recvq.c > * \brief Functions to manage the Receive Queues > */ > /* -*- Mode: C; c-basic-offset:4 ; -*- */ > /* > * (C) 2001 by Argonne National Laboratory. > * See COPYRIGHT in top-level directory. > */ > > #include "mpidimpl.h" > > /** > * \defgroup MPID_RECVQ MPID Receive Queue management > * > * Functions to manage the Receive Queues > */ > > /** \brief Unused lock macro to protect the receive queues */ > #define MPIDI_Recvq_lock() // MPID_Thread_lock(&MPIDI_Process.recvq_mutex) > /** \brief Unused unlock macro to protect the receive queues */ > #define MPIDI_Recvq_unlock() // MPID_Thread_unlock(&MPIDI_Process.recvq_mutex) > > > /** \brief Structure to group the common recvq pointers */ > static struct MPIDID_Recvq_t > { > struct MPID_Request * posted_head; /**< \brief The Head of the Posted queue */ > struct MPID_Request * posted_tail; /**< \brief The Tail of the Posted queue */ > struct MPID_Request * unexpected_head; /**< \brief The Head of the Unexpected queue */ > struct MPID_Request * unexpected_tail; /**< \brief The Tail of the Unexpected queue */ > } recvq; > > > /** > * \brief Set up the request queues > */ > void MPIDI_Recvq_init() > { > recvq.posted_head = NULL; > recvq.posted_tail = NULL; > recvq.unexpected_head = NULL; > recvq.unexpected_tail = NULL; > } > > > /** > * \brief Tear down the request queues > */ > void MPIDI_Recvq_finalize() > { > MPIDI_Recvq_DumpQueues(MPIDI_Process.verbose); > } > > > /** > * \brief Find a request in the unexpected queue > * \param [in] source Find by Sender > * \param [in] tag Find by Tag > * \param [in] context_id Find by Context ID (communicator) > * \return The matching UE request or NULL > */ > MPID_Request * MPIDI_Recvq_FU(int source, int tag, int context_id) > { > MPID_Request * rreq; > #ifdef USE_STATISTICS > unsigned search_length = 0; > #endif > > if (tag != MPI_ANY_TAG && source != MPI_ANY_SOURCE) > { > MPIDI_Recvq_lock(); > { > rreq = recvq.unexpected_head; > while(rreq != NULL) > { > #ifdef USE_STATISTICS > ++search_length; > #endif > if ( (rreq->dcmf.msginfo.msginfo.MPIctxt == context_id) && > (rreq->dcmf.msginfo.msginfo.MPIrank == source ) && > (rreq->dcmf.msginfo.msginfo.MPItag == tag ) > ) > { > MPID_Request_add_ref(rreq); > break; > } > > rreq = rreq->dcmf.next; > } > } > MPIDI_Recvq_unlock(); > } > else > { > MPIDI_Message_match match; > MPIDI_Message_match mask; > > match.context_id = context_id; > mask.context_id = ~0; > if (tag == MPI_ANY_TAG) > { > match.tag = 0; > mask.tag = 0; > } > else > { > match.tag = tag; > mask.tag = ~0; > } > if (source == MPI_ANY_SOURCE) > { > match.rank = 0; > mask.rank = 0; > } > else > { > match.rank = source; > mask.rank = ~0; > } > > MPIDI_Recvq_lock(); > { > rreq = recvq.unexpected_head; > while (rreq != NULL) > { > #ifdef USE_STATISTICS > ++search_length; > #endif > if ( ( rreq->dcmf.msginfo.msginfo.MPIctxt == match.context_id) && > ( (rreq->dcmf.msginfo.msginfo.MPIrank & mask.rank) == match.rank ) && > ( (rreq->dcmf.msginfo.msginfo.MPItag & mask.tag ) == match.tag ) > ) > { > MPID_Request_add_ref(rreq); > break; > } > > rreq = rreq->dcmf.next; > } > } > MPIDI_Recvq_unlock(); > } > > #ifdef USE_STATISTICS > MPIDI_Statistics_time(MPIDI_Statistics.recvq.unexpected_search, search_length); > #endif > > return rreq; > } > > > /** > * \brief Find a request in the unexpected queue and dequeue it > * \param [in] req Find by address of request object on sender > * \param [in] source Find by Sender > * \param [in] tag Find by Tag > * \param [in] context_id Find by Context ID (communicator) > * \return The matching UE request or NULL > */ > MPID_Request * MPIDI_Recvq_FDURSTC (MPID_Request * req, int source, int tag, int context_id) > { > MPID_Request * prev_rreq = NULL; /* previous request in queue */ > MPID_Request * cur_rreq = NULL; /* current request in queue */ > MPID_Request * matching_cur_rreq = NULL; /* matching request in queue */ > MPID_Request * matching_prev_rreq = NULL; /* previous in queue to match */ > #ifdef USE_STATISTICS > unsigned search_length = 0; > #endif > > /* ----------------------- */ > /* first we do the finding */ > /* ----------------------- */ > MPIDI_Recvq_lock(); > { > cur_rreq = recvq.unexpected_head; > while(cur_rreq != NULL) > { > #ifdef USE_STATISTICS > ++search_length; > #endif > if (cur_rreq->dcmf.msginfo.msginfo.req == req && > cur_rreq->dcmf.msginfo.msginfo.MPIctxt == context_id && > cur_rreq->dcmf.msginfo.msginfo.MPIrank == source && > cur_rreq->dcmf.msginfo.msginfo.MPItag == tag) > { > matching_prev_rreq = prev_rreq; > matching_cur_rreq = cur_rreq; > break; > } > prev_rreq = cur_rreq; > cur_rreq = cur_rreq->dcmf.next; > } > > /* ----------------------- */ > /* found nothing; return */ > /* ----------------------- */ > if (matching_cur_rreq == NULL) > goto fn_exit; > > /* --------------------------------------------------------------------- */ > /* adjust the "next" pointer of the request previous to the matching one */ > /* --------------------------------------------------------------------- */ > if (matching_prev_rreq != NULL) > matching_prev_rreq->dcmf.next = matching_cur_rreq->dcmf.next; > else > recvq.unexpected_head = matching_cur_rreq->dcmf.next; > > /* --------------------------------------- */ > /* adjust the request queue's tail pointer */ > /* --------------------------------------- */ > if (matching_cur_rreq->dcmf.next == NULL) > recvq.unexpected_tail = matching_prev_rreq; > } > fn_exit: > MPIDI_Recvq_unlock(); > > #ifdef USE_STATISTICS > MPIDI_Statistics_time(MPIDI_Statistics.recvq.unexpected_search, search_length); > #endif > > return (matching_cur_rreq); > } > > > /** > * \brief Find a request in the unexpected queue and dequeue it > * \param [in] req Find by address of request object on sender > * \return The matching UE request or NULL > */ > MPID_Request * MPIDI_Recvq_FDUR (MPID_Request * req) > { > MPID_Request * prev_rreq = NULL; /* previous request in queue */ > MPID_Request * cur_rreq = NULL; /* current request in queue */ > MPID_Request * matching_cur_rreq = NULL; /* matching request in queue */ > MPID_Request * matching_prev_rreq = NULL; /* previous in queue to match */ > #ifdef USE_STATISTICS > unsigned search_length = 0; > #endif > > /* ----------------------- */ > /* first we do the finding */ > /* ----------------------- */ > MPIDI_Recvq_lock(); > { > cur_rreq = recvq.unexpected_head; > while(cur_rreq != NULL) > { > #ifdef USE_STATISTICS > ++search_length; > #endif > if (cur_rreq->dcmf.msginfo.msginfo.req == req) > { > matching_prev_rreq = prev_rreq; > matching_cur_rreq = cur_rreq; > break; > } > prev_rreq = cur_rreq; > cur_rreq = cur_rreq->dcmf.next; > } > > /* ----------------------- */ > /* found nothing; return */ > /* ----------------------- */ > if (matching_cur_rreq == NULL) > goto fn_exit; > > /* --------------------------------------------------------------------- */ > /* adjust the "next" pointer of the request previous to the matching one */ > /* --------------------------------------------------------------------- */ > if (matching_prev_rreq != NULL) > matching_prev_rreq->dcmf.next = matching_cur_rreq->dcmf.next; > else > recvq.unexpected_head = matching_cur_rreq->dcmf.next; > > /* --------------------------------------- */ > /* adjust the request queue's tail pointer */ > /* --------------------------------------- */ > if (matching_cur_rreq->dcmf.next == NULL) > recvq.unexpected_tail = matching_prev_rreq; > } > fn_exit: > MPIDI_Recvq_unlock(); > > #ifdef USE_STATISTICS > MPIDI_Statistics_time(MPIDI_Statistics.recvq.unexpected_search, search_length); > #endif > > return (matching_cur_rreq); > } > > > /** > * \brief Find a request in the unexpected queue and dequeue it, or allocate a new request and enqueue it in the posted queue > * \param [in] source Find by Sender > * \param [in] tag Find by Tag > * \param [in] context_id Find by Context ID (communicator) > * \param [out] foundp TRUE iff the request was found > * \return The matching UE request or the new posted request > */ > MPID_Request * MPIDI_Recvq_FDU_or_AEP(int source, int tag, int context_id, int * foundp) > { > int found; > MPID_Request * rreq; > MPID_Request * prev_rreq; > #ifdef USE_STATISTICS > unsigned search_length = 0; > #endif > > MPIDI_Recvq_lock(); > { > if (tag != MPI_ANY_TAG && source != MPI_ANY_SOURCE) > { > prev_rreq = NULL; > rreq = recvq.unexpected_head; > while(rreq != NULL) > { > #ifdef USE_STATISTICS > ++search_length; > #endif > if ( (rreq->dcmf.msginfo.msginfo.MPIctxt == context_id) && > (rreq->dcmf.msginfo.msginfo.MPIrank == source ) && > (rreq->dcmf.msginfo.msginfo.MPItag == tag ) > ) > { > if (prev_rreq != NULL) > { > prev_rreq->dcmf.next = rreq->dcmf.next; > } > else > { > recvq.unexpected_head = rreq->dcmf.next; > } > if (rreq->dcmf.next == NULL) > { > recvq.unexpected_tail = prev_rreq; > } > found = TRUE; > goto lock_exit; > } > > prev_rreq = rreq; > rreq = rreq->dcmf.next; > } > } > else > { > MPIDI_Message_match match; > MPIDI_Message_match mask; > > match.context_id = context_id; > mask.context_id = ~0; > if (tag == MPI_ANY_TAG) > { > match.tag = 0; > mask.tag = 0; > } > else > { > match.tag = tag; > mask.tag = ~0; > } > if (source == MPI_ANY_SOURCE) > { > match.rank = 0; > mask.rank = 0; > } > else > { > match.rank = source; > mask.rank = ~0; > } > > prev_rreq = NULL; > rreq = recvq.unexpected_head; > while (rreq != NULL) > { > #ifdef USE_STATISTICS > ++search_length; > #endif > if ( ( rreq->dcmf.msginfo.msginfo.MPIctxt == match.context_id) && > ( (rreq->dcmf.msginfo.msginfo.MPIrank & mask.rank) == match.rank ) && > ( (rreq->dcmf.msginfo.msginfo.MPItag & mask.tag ) == match.tag ) > ) > { > if (prev_rreq != NULL) > { > prev_rreq->dcmf.next = rreq->dcmf.next; > } > else > { > recvq.unexpected_head = rreq->dcmf.next; > } > if (rreq->dcmf.next == NULL) > { > recvq.unexpected_tail = prev_rreq; > } > found = TRUE; > goto lock_exit; > } > > prev_rreq = rreq; > rreq = rreq->dcmf.next; > } > } > > /* A matching request was not found in the unexpected queue, > so we need to allocate a new request and add it to the > posted queue */ > rreq = MPID_Request_create(); > if (rreq != NULL) > { > MPIU_Object_set_ref(rreq, 2); > rreq->kind = MPID_REQUEST_RECV; > rreq->dcmf.msginfo.msginfo.MPItag = tag; > rreq->dcmf.msginfo.msginfo.MPIrank = source; > rreq->dcmf.msginfo.msginfo.MPIctxt = context_id; > rreq->dcmf.next = NULL; > > if (recvq.posted_tail != NULL) > { > recvq.posted_tail->dcmf.next = rreq; > } > else > { > recvq.posted_head = rreq; > } > recvq.posted_tail = rreq; > } > > found = FALSE; > } > lock_exit: > MPIDI_Recvq_unlock(); > > #ifdef USE_STATISTICS > MPIDI_Statistics_time(MPIDI_Statistics.recvq.unexpected_search, search_length); > #endif > > *foundp = found; > return rreq; > } > > > /** > * \brief Find a request in the posted queue and dequeue it > * \param [in] req Find by address of request object on sender > * \return The matching posted request or NULL > */ > int MPIDI_Recvq_FDPR(MPID_Request * req) > { > MPID_Request * cur_rreq = NULL; > MPID_Request * prev_rreq = NULL; > int found = FALSE; > #ifdef USE_STATISTICS > unsigned search_length = 0; > #endif > > MPIDI_Recvq_lock(); > { > cur_rreq = recvq.posted_head; > while (cur_rreq != NULL) > { > #ifdef USE_STATISTICS > ++search_length; > #endif > if (cur_rreq == req) > { > if (prev_rreq != NULL) > { > prev_rreq->dcmf.next = cur_rreq->dcmf.next; > } > else > { > recvq.posted_head = cur_rreq->dcmf.next; > } > if (cur_rreq->dcmf.next == NULL) > { > recvq.posted_tail = prev_rreq; > } > > found = TRUE; > break; > } > > prev_rreq = cur_rreq; > cur_rreq = cur_rreq->dcmf.next; > } > } > MPIDI_Recvq_unlock(); > > #ifdef USE_STATISTICS > MPIDI_Statistics_time(MPIDI_Statistics.recvq.posted_search, search_length); > #endif > > return found; > } > > > /** > * \brief Find a request in the posted queue and dequeue it, or allocate a new request and enqueue it in the unexpected queue > * \param [in] source Find by Sender > * \param [in] tag Find by Tag > * \param [in] context_id Find by Context ID (communicator) > * \param [out] foundp TRUE iff the request was found > * \return The matching posted request or the new UE request > */ > MPID_Request * MPIDI_Recvq_FDP_or_AEU(int source, int tag, int context_id, int * foundp) > { > MPID_Request * rreq; > MPID_Request * prev_rreq = NULL; > int found = FALSE; > #ifdef USE_STATISTICS > unsigned search_length = 0; > #endif > > > MPIDI_Recvq_lock(); > { > rreq = recvq.posted_head; > while (rreq != NULL) > { > #ifdef USE_STATISTICS > ++search_length; > #endif > if ( (rreq->dcmf.msginfo.msginfo.MPIctxt == context_id) && > (rreq->dcmf.msginfo.msginfo.MPIrank == source || rreq->dcmf.msginfo.msginfo.MPIrank == MPI_ANY_SOURCE) && > (rreq->dcmf.msginfo.msginfo.MPItag == tag || rreq->dcmf.msginfo.msginfo.MPItag == MPI_ANY_TAG) > ) > { > if (prev_rreq != NULL) > { > prev_rreq->dcmf.next = rreq->dcmf.next; > } > else > { > recvq.posted_head = rreq->dcmf.next; > } > if (rreq->dcmf.next == NULL) > { > recvq.posted_tail = prev_rreq; > } > found = TRUE; > goto lock_exit; > } > > prev_rreq = rreq; > rreq = rreq->dcmf.next; > } > > /* A matching request was not found in the posted queue, so we > need to allocate a new request and add it to the unexpected > queue */ > rreq = MPID_Request_create(); > if (rreq != NULL) > { > MPIU_Object_set_ref(rreq, 2); > rreq->kind = MPID_REQUEST_RECV; > MPID_Request_setMatch(rreq, tag, source, context_id); > rreq->dcmf.next = NULL; > > if (recvq.unexpected_tail != NULL) > { > recvq.unexpected_tail->dcmf.next = rreq; > } > else > { > recvq.unexpected_head = rreq; > } > recvq.unexpected_tail = rreq; > } > > found = FALSE; > } > lock_exit: > MPIDI_Recvq_unlock(); > > #ifdef USE_STATISTICS > MPIDI_Statistics_time(MPIDI_Statistics.recvq.posted_search, search_length); > #endif > > *foundp = found; > return rreq; > } > > > /** > * \brief Dump the queues > */ > void MPIDI_Recvq_DumpQueues (int verbose) > { > if(verbose == 0) > return; > > MPID_Request * rreq = recvq.posted_head; > MPID_Request * prev_rreq = NULL; > unsigned i=0, numposted=0, numue=0; > unsigned postedbytes=0, uebytes=0; > > fprintf(stderr,"Posted Queue:\n"); > fprintf(stderr,"-------------\n"); > while (rreq != NULL) > { > if(verbose >= 2) > fprintf (stderr, "P %d: MPItag=%d MPIrank=%d ctxt=%d cc=%d count=%d\n", > i++, > rreq->dcmf.msginfo.msginfo.MPItag, > rreq->dcmf.msginfo.msginfo.MPIrank, > rreq->dcmf.msginfo.msginfo.MPIctxt, > rreq->cc, > rreq->dcmf.userbufcount > ); > numposted++; > postedbytes+=rreq->dcmf.userbufcount; > prev_rreq = rreq; > rreq = rreq->dcmf.next; > } > fprintf(stderr, "Posted Requests %d, Total Mem: %d bytes\n", > numposted, postedbytes); > > > i=0; > rreq = recvq.unexpected_head; > fprintf(stderr, "Unexpected Queue:\n"); > fprintf(stderr, "-----------------\n"); > while (rreq != NULL) > { > if(verbose >= 2) > fprintf (stderr, "UE %d: MPItag=%d MPIrank=%d ctxt=%d cc=%d uebuf=%p uebuflen=%u\n", > i++, > rreq->dcmf.msginfo.msginfo.MPItag, > rreq->dcmf.msginfo.msginfo.MPIrank, > rreq->dcmf.msginfo.msginfo.MPIctxt, > *rreq->cc_ptr, > rreq->dcmf.uebuf, > rreq->dcmf.uebuflen); > numue++; > uebytes+=rreq->dcmf.uebuflen; > prev_rreq = rreq; > rreq = rreq->dcmf.next; > } > fprintf(stderr, "Unexpected Requests %d, Total Mem: %d bytes\n", > numue, uebytes); > > } diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/impl/mpid_request.c bgp-mpich2/src/mpid/dcmf/src/impl/mpid_request.c 0a1,134 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file src/impl/mpid_request.c > * \brief Accessors and actors for MPID Requests > */ > #include "mpidimpl.h" > > #ifndef MPID_REQUEST_PREALLOC > #define MPID_REQUEST_PREALLOC 8 > #endif > > /** > * \defgroup MPID_REQUEST MPID Request object management > * > * Accessors and actors for MPID Requests > */ > > > /* these are referenced by src/mpi/pt2pt/wait.c in PMPI_Wait! */ > MPID_Request MPID_Request_direct[MPID_REQUEST_PREALLOC]; > MPIU_Object_alloc_t MPID_Request_mem = > { > 0, 0, 0, 0, MPID_REQUEST, sizeof(MPID_Request), > MPID_Request_direct, > MPID_REQUEST_PREALLOC > }; > > > /** > * \brief Create and initialize a new request > */ > > MPID_Request * MPID_Request_create() > { > MPID_Request * req; > > req = MPIU_Handle_obj_alloc(&MPID_Request_mem); > if (req == NULL) > MPID_Abort(NULL, MPI_ERR_NO_SPACE, -1, "Cannot allocate Request"); > > MPID_assert (HANDLE_GET_MPI_KIND(req->handle) == MPID_REQUEST); > MPIU_Object_set_ref(req, 1); > req->cc = 1; > req->cc_ptr = & req->cc; > req->status.MPI_SOURCE = MPI_UNDEFINED; > req->status.MPI_TAG = MPI_UNDEFINED; > req->status.MPI_ERROR = MPI_SUCCESS; > req->status.count = 0; > req->status.cancelled = FALSE; > req->comm = NULL; > > memset(&(req->dcmf),0x00,sizeof(struct MPIDI_DCMF_Request)); > /* The above memset takes care of clearing the following fields, */ > /* and more: */ > /* req->dcmf.userbuf = NULL; */ > /* req->dcmf.uebuf = NULL; */ > /* req->dcmf.datatype_ptr = NULL; */ > /* req->dcmf.cancel_pending= FALSE; */ > /* MPID_Request_setSelf (req,0); /\* not a self request *\/ */ > /* MPID_Request_setSync (req,0); /\* not a sync request *\/ */ > req->dcmf.state = MPIDI_DCMF_INITIALIZED; > MPID_Request_setCA (req, MPIDI_DCMF_CA_COMPLETE); > MPID_Request_setType (req, MPIDI_DCMF_REQUEST_TYPE_RECV); > > return req; > } > > MPID_Request * MPID_SendRequest_create() > { > MPID_Request *sreq = MPID_Request_create(); > MPID_Request_setType(sreq, MPIDI_DCMF_REQUEST_TYPE_SEND); > MPID_Request_setPeerRequest(sreq, sreq); > MPIU_Object_set_ref(sreq, 2); > return sreq; > } > > /* *********************************************************************** */ > /* destroy a request */ > /* *********************************************************************** */ > > void MPID_Request_destroy(MPID_Request * req) > { > MPID_assert(HANDLE_GET_MPI_KIND(req->handle) == MPID_REQUEST); > MPID_assert(req->ref_count == 0); > > if (req->comm) MPIR_Comm_release(req->comm, 0); > if (req->dcmf.datatype_ptr) MPID_Datatype_release(req->dcmf.datatype_ptr); > /* MPID_assert(req->dcmf.uebuf == NULL); */ > > MPIU_Handle_obj_free(&MPID_Request_mem, req); > } > > void MPID_Request_release_ref(MPID_Request * req, int * ref_count) > { > MPID_assert(HANDLE_GET_MPI_KIND(req->handle) == MPID_REQUEST); > MPIU_Object_release_ref(req, ref_count); > MPID_assert(req->ref_count >= 0); > } > > void MPID_Request_release (MPID_Request *req) > { > int ref_count; > MPID_Request_release_ref(req, &ref_count); > if (ref_count == 0) MPID_Request_destroy(req); > } > > /* *********************************************************************** */ > /* Dealing with completion counts */ > /* *********************************************************************** */ > > void MPID_Request_complete (MPID_Request *req) > { > int cc; > MPID_Request_decrement_cc(req, &cc); > MPID_assert(cc >= 0); > if (cc == 0) /* decrement completion count; if 0, release request */ > { > MPID_Request_release(req); > MPID_Progress_signal(); > } > } > > void MPID_Request_set_completed (MPID_Request *req) > { > *(req)->cc_ptr = 0; /* force completion count to 0 */ > MPID_Progress_signal(); > } diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/impl/mpid_statistics.c bgp-mpich2/src/mpid/dcmf/src/impl/mpid_statistics.c 0a1,51 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file src/impl/mpid_statistics.c > * \brief The statistics implementation > */ > > #include "mpidimpl.h" > > #ifdef USE_STATISTICS > #warning Statistic are ON > > MPIDI_Statistics_t MPIDI_Statistics; > > #define MPIDI_Statistics_print(r, s) \ > ({ \ > double s0 = s.s0; \ > double s1 = s.s1; \ > double s2 = s.s2; \ > printf("%3d: Statistics for \"" #s "\":\n", r); \ > printf(" Count : %u\n", s.s0); \ > printf(" Max : %u\n", s.max); \ > printf(" Mean : %g\n", s1/s0); \ > printf(" Variance : %g\n", (s0*s2 - s1*s1) / (s0*s0)); \ > }) > > void MPIDI_Statistics_init() > { > memset(&MPIDI_Statistics, 0, sizeof(MPIDI_Statistics)); > } > > void MPIDI_Statistics_finalize() > { > if (MPIDI_Process.statistics) > { > MPIDI_Statistics_print(0, MPIDI_Statistics.recvq.posted_search); > MPIDI_Statistics_print(0, MPIDI_Statistics.recvq.unexpected_search); > } > } > > #else > #warning Statistic are OFF > void MPIDI_Statistics_init() {} > void MPIDI_Statistics_finalize() {} > #endif diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/Makefile.sm bgp-mpich2/src/mpid/dcmf/src/Makefile.sm 0a1,3 > SUBDIRS= . impl misc pt2pt persistent onesided comm coll > INCLUDES = -I${master_top_srcdir}/src/include -I${top_builddir}/src/include > lib${MPILIBNAME}_a_SOURCES = diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/misc/Makefile.sm bgp-mpich2/src/mpid/dcmf/src/misc/Makefile.sm 0a1,16 > SUBDIRS= . > INCLUDES = -I${master_top_srcdir}/src/include -I${top_builddir}/src/include > lib${MPILIBNAME}_a_SOURCES = mpid_abort.c \ > mpid_comm_spawn.c \ > mpid_init.c \ > mpid_finalize.c \ > mpid_get_universe_size.c \ > mpid_probe.c \ > mpid_iprobe.c \ > mpid_progress.c \ > mpid_alloc_mem.c \ > mpid_free_mem.c \ > mpid_getpname.c \ > mpid_vc.c \ > mpid_time.c \ > mpix.c diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/misc/mpid_abort.c bgp-mpich2/src/mpid/dcmf/src/misc/mpid_abort.c 0a1,108 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file src/misc/mpid_abort.c > * \brief Handle general operations assosicated with erroneous job termination > */ > #include "mpidimpl.h" > > extern int backtrace(void **buffer, int size); /**< GlibC backtrace support */ > extern char **backtrace_symbols(void *const *buffer, int size); /**< GlibC backtrace support */ > > /** > * \brief The central parts of the MPID_Abort() call > * > * \param[in] comm The communicator associated with the failure (can be null). > * \param[in] mpi_errno The MPI error associated with the failure (can be zero). > * \param[in] exit_code The requested exit code, however BG features imply that exit(1) will always be used. > * \param[in] error_msg The message to display (may be NULL_ > * > * This is the majority of the call to MPID_Abort(). The only > * difference is that it does not call exit. That allows it to be > * used as a test function to ensure that the output is what you would > * expect. > * > * MPID_Abort_core() simply uses the same params from MPID_Abort(). > */ > void MPID_Abort_core(MPID_Comm * comm, int mpi_errno, int exit_code, const char *user_str) > { > char sys_str[MPI_MAX_ERROR_STRING+5] = ""; > char comm_str[MPI_MAX_ERROR_STRING] = ""; > char world_str[MPI_MAX_ERROR_STRING] = ""; > char error_str[2*MPI_MAX_ERROR_STRING + 128]; > > if (MPIR_Process.comm_world) > { > int rank = MPIR_Process.comm_world->rank; > snprintf(world_str, sizeof(world_str), " on node %d", rank); > } > if (comm) > { > int rank = comm->rank; > int handle = comm->handle; > snprintf(comm_str, sizeof(comm_str), " (rank %d in comm %d)", rank, handle); > } > if (!user_str) > user_str = "Internal error"; > if (mpi_errno != MPI_SUCCESS) > { > char msg[MPI_MAX_ERROR_STRING] = ""; > MPIR_Err_get_string(mpi_errno, msg, MPI_MAX_ERROR_STRING, NULL); > snprintf(sys_str, sizeof(msg), " (%s)", msg); > } > > snprintf(error_str, sizeof(error_str), "Abort(%d)%s%s: %s%s\n", exit_code, world_str, comm_str, user_str, sys_str); > MPIU_Error_printf("%s", error_str); > > if (MPIDI_Process.verbose) > MPID_Dump_stacks(); > > fflush(stderr); fflush(stdout); > } > > /** > * \brief The central parts of the MPID_Abort call > * \param[in] comm The communicator associated with the failure (can be null). > * \param[in] mpi_errno The MPI error associated with the failure (can be zero). > * \param[in] exit_code The requested exit code, however BG features imply that exit(1) will always be used. > * \param[in] error_msg The message to display (may be NULL_ > * \returns MPI_ERR_INTERN > * > * This function SHOULD NEVER return. > */ > int MPID_Abort(MPID_Comm * comm, int mpi_errno, int exit_code, const char *error_msg) > { > MPID_Abort_core(comm, mpi_errno, exit_code, error_msg); > abort(); > return MPI_ERR_INTERN; > } > > > /** > * \brief Print the current system stack > * > * The first frame (this function) is discarded to make the trace look nicer. > */ > void MPID_Dump_stacks() > { > void *array[32]; > size_t i; > size_t size = backtrace(array, 32); > char **strings = backtrace_symbols(array, size); > fprintf(stderr, "Dumping %zd frames:\n", size - 1); > for (i = 1; i < size; i++) > { > if (strings != NULL) > fprintf(stderr, "\tFrame %d: %p: %s\n", i, array[i], strings[i]); > else > fprintf(stderr, "\tFrame %d: %p\n", i, array[i]); > } > > free(strings); /* Since this is not allocated by MPIU_Malloc, do not use MPIU_Free */ > } diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/misc/mpid_alloc_mem.c bgp-mpich2/src/mpid/dcmf/src/misc/mpid_alloc_mem.c 0a1,27 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file src/misc/mpid_alloc_mem.c > * \brief ??? > */ > /* -*- Mode: C; c-basic-offset:4 ; -*- */ > /* > * > * (C) 2001 by Argonne National Laboratory. > * See COPYRIGHT in top-level directory. > */ > > #include "mpidimpl.h" > > void *MPID_Alloc_mem( size_t size, MPID_Info *info_ptr ) > { > void *ap; > ap = MPIU_Malloc(size); > return ap; > } diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/misc/mpid_comm_spawn.c bgp-mpich2/src/mpid/dcmf/src/misc/mpid_comm_spawn.c 0a1,31 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file src/misc/mpid_comm_spawn.c > * \brief ??? > */ > /* -*- Mode: C; c-basic-offset:2 ; -*- */ > /* > * (C) 2001 by Argonne National Laboratory. > * See COPYRIGHT in top-level directory. > */ > > #include "mpidimpl.h" > > /* > * MPID_Comm_spawn() > */ > int MPID_Comm_spawn(char *command, char *argv[], int maxprocs, MPI_Info info, > int root, MPID_Comm *comm, MPID_Comm *intercomm, > int array_of_errcodes[]) > { > int mpi_errno = MPI_SUCCESS; > mpi_errno = MPI_ERR_INTERN; > return mpi_errno; > } diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/misc/mpid_finalize.c bgp-mpich2/src/mpid/dcmf/src/misc/mpid_finalize.c 0a1,37 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file src/misc/mpid_finalize.c > * \brief Normal job termination code > */ > #include "mpidimpl.h" > #include "pmi.h" > > /** > * \brief Shut down the system > * > * At this time, no attempt is made to free memory being used for MPI structures. > * \return MPI_SUCCESS > */ > int MPID_Finalize() > { > PMPI_Barrier(MPI_COMM_WORLD); > > /* ------------------------- */ > /* shutdown the statistics */ > /* ------------------------- */ > MPIDI_Statistics_finalize(); > > /* ------------------------- */ > /* shutdown request queues */ > /* ------------------------- */ > MPIDI_Recvq_finalize(); > > return MPI_SUCCESS; > } diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/misc/mpid_free_mem.c bgp-mpich2/src/mpid/dcmf/src/misc/mpid_free_mem.c 0a1,27 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file src/misc/mpid_free_mem.c > * \brief ??? > */ > /* -*- Mode: C; c-basic-offset:4 ; -*- */ > /* > * > * (C) 2001 by Argonne National Laboratory. > * See COPYRIGHT in top-level directory. > */ > > #include "mpidimpl.h" > > int MPID_Free_mem( void *ptr ) > { > int mpi_errno = MPI_SUCCESS; > MPIU_Free(ptr); > return mpi_errno; > } diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/misc/mpid_getpname.c bgp-mpich2/src/mpid/dcmf/src/misc/mpid_getpname.c 0a1,29 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file src/misc/mpid_getpname.c > * \brief Device interface to MPI_Get_processor_name() > */ > #include "mpidimpl.h" > > /** > * \brief Device interface to MPI_Get_processor_name() > * \param[out] name Storage for the name as a string > * \param[in] namelen The maximum allowed length > * \param[out] resultlen The actual length written > * \returns MPI_SUCCESS > * > * All this does is convert the rank to a string and return the data > */ > int MPID_Get_processor_name(char * name, int namelen, int * resultlen) > { > snprintf(name, namelen, "%s", mpid_hw.name); > *resultlen = (int)strlen(name); > return MPI_SUCCESS; > } diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/misc/mpid_get_universe_size.c bgp-mpich2/src/mpid/dcmf/src/misc/mpid_get_universe_size.c 0a1,29 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file src/misc/mpid_get_universe_size.c > * \brief ??? > */ > /* -*- Mode: C; c-basic-offset:4 ; -*- */ > /* > * (C) 2001 by Argonne National Laboratory. > * See COPYRIGHT in top-level directory. > */ > > #include "mpidimpl.h" > > /* > * MPID_Get_universe_size() > */ > int MPID_Get_universe_size(int * universe_size) > { > int mpi_errno = MPI_SUCCESS; > *universe_size = MPIR_UNIVERSE_SIZE_NOT_AVAILABLE; > return mpi_errno; > } diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/misc/mpid_init.c bgp-mpich2/src/mpid/dcmf/src/misc/mpid_init.c 0a1,215 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file src/misc/mpid_init.c > * \brief Normal job startup code > */ > #include "mpidimpl.h" > #include "pmi.h" > #include > > MPIDI_Protocol_t MPIDI_Protocols; > MPIDI_Process_t MPIDI_Process; > DCMF_Hardware_t mpid_hw; > > > /** > * \brief Initialize MPICH2 at ADI level. > * \param[in,out] argc Unused > * \param[in,out] argv Unused > * \param[in] requested The thread model requested by the user. > * \param[out] provided The thread model provided to user. This will be the same as requested, except in VNM. This behavior is handled by DCMF_Messager_configure() > * \param[out] has_args Set to TRUE > * \param[out] has_env Set to TRUE > * \return MPI_SUCCESS > */ > int MPID_Init(int * argc, > char *** argv, > int requested, > int * provided, > int * has_args, > int * has_env) > { > int pg_rank, pg_size, i, rc; > int tempthread; > MPIDI_VC * vc_table = NULL; > MPID_Comm * comm; > > /* ------------------------- */ > /* initialize the statistics */ > /* ------------------------- */ > MPIDI_Statistics_init(); > > /* ------------------------- */ > /* initialize request queues */ > /* ------------------------- */ > MPIDI_Recvq_init(); > > /* ----------------------------------- */ > /* Read the ENV vars to setup defaults */ > /* ----------------------------------- */ > MPIDI_Env_setup(); > > > /* ----------------------------- */ > /* Initialize messager */ > /* ----------------------------- */ > DCMF_Messager_initialize(); > DCMF_Collective_initialize(); > DCMF_Hardware(&mpid_hw); > > /* ---------------------------------- */ > /* Register eager point-to-point send */ > /* ---------------------------------- */ > DCMF_Send_Configuration_t default_config = > { > DCMF_DEFAULT_SEND_PROTOCOL, > (DCMF_RecvSendShort) MPIDI_BG2S_RecvShortCB, > NULL, > (DCMF_RecvSend) MPIDI_BG2S_RecvCB, > NULL, > }; > DCMF_Send_register (&MPIDI_Protocols.send, &default_config); > > /* ---------------------------------- */ > /* Register rzv point-to-point rts */ > /* ---------------------------------- */ > default_config.cb_recv_short = (DCMF_RecvSendShort) MPIDI_BG2S_RecvRzvCB; > default_config.cb_recv = (DCMF_RecvSend) NULL; > DCMF_Send_register (&MPIDI_Protocols.rzv, &default_config); > > /* --------------------------- */ > /* Register point-to-point get */ > /* --------------------------- */ > DCMF_Get_Configuration_t get_config = { DCMF_DEFAULT_GET_PROTOCOL }; > DCMF_Get_register (&MPIDI_Protocols.get, &get_config); > > /* ---------------------------------- */ > /* Register control send */ > /* ---------------------------------- */ > DCMF_Control_Configuration_t control_config = > { > DCMF_DEFAULT_CONTROL_PROTOCOL, > (DCMF_RecvControl) MPIDI_BG2S_ControlCB, NULL > }; > DCMF_Control_register (&MPIDI_Protocols.control, &control_config); > > /* ---------------------------------- */ > /* Register the collectives */ > /* ---------------------------------- */ > MPIDI_Coll_register(); > > /* ------------------------------------------------------ */ > /* Set process attributes. */ > /* ------------------------------------------------------ */ > MPIR_Process.attrs.tag_ub = INT_MAX; > MPIR_Process.attrs.wtime_is_global = 1; > if (MPIDI_Process.optimized.topology) > MPIR_Process.dimsCreate = MPID_Dims_create; > > > /* ---------------------------------------- */ > /* Get my rank and the process size */ > /* ---------------------------------------- */ > pg_rank = DCMF_Messager_rank(); > pg_size = DCMF_Messager_size(); > > /* ------------------------------------ */ > /* Initialize Virtual Connection table */ > /* ------------------------------------ */ > > vc_table = MPIU_Malloc(sizeof(MPIDI_VC) * pg_size); /* !!! */ > MPID_assert(vc_table != NULL); > > for (i = 0; i < pg_size; i++) > { > vc_table[i].ref_count = 0; > vc_table[i].lpid = i; > } > > > /* -------------------------------- */ > /* Initialize MPI_COMM_WORLD object */ > /* -------------------------------- */ > > comm = MPIR_Process.comm_world; > comm->rank = pg_rank; > comm->remote_size = comm->local_size = pg_size; > rc = MPID_VCRT_Create(comm->remote_size, &comm->vcrt); > MPID_assert(rc == MPI_SUCCESS); > rc = MPID_VCRT_Get_ptr(comm->vcrt, &comm->vcr); > MPID_assert(rc == MPI_SUCCESS); > for (i=0; i { > vc_table[i].ref_count++; > comm->vcr[i] = &vc_table[i]; > } > > /* comm_create for MPI_COMM_WORLD needs this information to ensure no > * barriers are done in dual mode with multithreading > * We don't get the thread_provided updated until AFTER MPID_Init is > * finished so we need to know the requested thread level in comm_create > */ > tempthread = MPIR_ThreadInfo.thread_provided; > MPIR_ThreadInfo.thread_provided = requested; > MPIDI_Comm_create(comm); > MPIR_ThreadInfo.thread_provided = tempthread; > > /* ------------------------------- */ > /* Initialize MPI_COMM_SELF object */ > /* ------------------------------- */ > > comm = MPIR_Process.comm_self; > comm->rank = 0; > comm->remote_size = comm->local_size = 1; > rc = MPID_VCRT_Create(comm->remote_size, &comm->vcrt); > MPID_assert(rc == MPI_SUCCESS); > rc = MPID_VCRT_Get_ptr(comm->vcrt, &comm->vcr); > MPID_assert(rc == MPI_SUCCESS); > vc_table[pg_rank].ref_count++; > comm->vcr[0] = &vc_table[pg_rank]; > > /* ------------------------------- */ > /* Initialize timer data */ > /* ------------------------------- */ > MPID_Wtime_init(); > > /* ------------------------------- */ > *has_args = TRUE; > *has_env = TRUE; > > > { > DCMF_Configure_t dcmf_config; > memset(&dcmf_config, 0x00, sizeof(DCMF_Configure_t)); > > // When interrupts are on, must use MPI_THREAD_MULTIPLE > // so locking is done to interlock between the main > // thread and the interrupt handler thread. > if ( MPIDI_Process.use_interrupts ) > dcmf_config.interrupts = DCMF_INTERRUPTS_ON; > else > dcmf_config.interrupts = DCMF_INTERRUPTS_OFF; > > // Attempt to set the same thread level as requestd > dcmf_config.thread_level = requested; > > // Get the actual values back > DCMF_Messager_configure(&dcmf_config, &dcmf_config); > *provided = dcmf_config.thread_level; > } > > return MPI_SUCCESS; > } > > > int MPID_InitCompleted(void) > { > return MPI_SUCCESS; > } diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/misc/mpid_iprobe.c bgp-mpich2/src/mpid/dcmf/src/misc/mpid_iprobe.c 0a1,47 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file src/misc/mpid_iprobe.c > * \brief ??? > */ > #include "mpidimpl.h" > > int MPID_Iprobe(int source, > int tag, > MPID_Comm * comm, > int context_offset, > int *flag, > MPI_Status * status) > { > MPID_Request * rreq; > const int context = comm->recvcontext_id + context_offset; > > if (source == MPI_PROC_NULL) > { > MPIR_Status_set_procnull(status); > /* We set the flag to true because an MPI_Recv with this rank will > * return immediately */ > *flag = TRUE; > return MPI_SUCCESS; > } > rreq = MPIDI_Recvq_FU(source, tag, context); > if (rreq != NULL) > { > if (status != MPI_STATUS_IGNORE) *status = rreq->status; > MPID_Request_release(rreq); > *flag = TRUE; > return MPI_SUCCESS; > } > else > { > MPID_Progress_poke(); > *flag = FALSE; > } > return MPI_SUCCESS; > } diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/misc/mpid_probe.c bgp-mpich2/src/mpid/dcmf/src/misc/mpid_probe.c 0a1,45 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file src/misc/mpid_probe.c > * \brief ??? > */ > #include "mpidimpl.h" > > int MPID_Probe(int source, > int tag, > MPID_Comm * comm, > int context_offset, > MPI_Status * status) > { > MPID_Request * rreq; > MPID_Progress_state state; > const int context = comm->recvcontext_id + context_offset; > > if (source == MPI_PROC_NULL) > { > MPIR_Status_set_procnull(status); > return MPI_SUCCESS; > } > for(;;) > { > MPID_Progress_start(&state); > rreq = MPIDI_Recvq_FU(source, tag, context); > if (rreq == NULL) MPID_Progress_wait(&state); > else > { > if (status != MPI_STATUS_IGNORE) *status = rreq->status; > > MPID_Request_release(rreq); > MPID_Progress_end(&state); > return MPI_SUCCESS; > } > } > return MPI_SUCCESS; > } diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/misc/mpid_progress.c bgp-mpich2/src/mpid/dcmf/src/misc/mpid_progress.c 0a1,107 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file src/misc/mpid_progress.c > * \brief Maintain the state and rules of the MPI progress semantics > */ > #include "mpidimpl.h" > > /** > * \defgroup MPID_PROGRESS MPID Progress engine > * > * Maintain the state and rules of the MPI progress semantics > */ > > > /** > * \brief A counter to allow the detection of changes to message state. > * > * It is theoretically possible to miss an event : if exactly 2^32 (4 > * Billion) events complete in a singal call to > * DCMF_Messager_advance(), the comparison would still be true. We > * assume that this will not happen. > */ > static volatile unsigned _requests; > > /** > * \brief Unused, provided since MPI calls it. > * \param[in] state Unused > */ > void MPID_Progress_start(MPID_Progress_state * state) > { > } > > > /** > * \brief Unused, provided since MPI calls it. > * \param[in] state Unused > */ > void MPID_Progress_end(MPID_Progress_state * state) > { > } > > /** > * \brief This function blocks until a request completes > * \param[in] state Unused > * > * It does not check what has completed, only that the counter > * changes. That happens whenever there is a call to > * MPID_Progress_signal(). It is therefore important that the ADI > * layer include a call to MPID_Progress_signal() whenever something > * occurs that a node might be waiting on. > * > */ > int MPID_Progress_wait(MPID_Progress_state * state) > { > int x = _requests; > while (x == _requests) { > DCMF_Messager_advance(); > /* The point of locking and unlocking here is that it allows > * other threads to access the MPI routines when we are blocked. > * If we do not release the lock we are holding, no other thread > * will ever enter MPI--that violates the THREAD_MULTIPLE > * requirements. > */ > MPID_CS_CYCLE(); > } > return MPI_SUCCESS; > } > > /** > * \brief This function advances the connection manager. > * > * It gets called when progress is desired (e.g. MPI_Iprobe), but > * nobody wants to block for it. > */ > int MPID_Progress_poke() > { > DCMF_Messager_advance(); > return MPI_SUCCESS; > } > > /** > * \brief The same as MPID_Progress_poke() > */ > int MPID_Progress_test() > { > DCMF_Messager_advance(); > return MPI_SUCCESS; > } > > /** > * \brief Signal MPID_Progress_wait() that something is done/changed > * > * It is therefore important that the ADI layer include a call to > * MPID_Progress_signal() whenever something occurs that a node might > * be waiting on. > */ > void MPID_Progress_signal() > { > _requests++; > } diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/misc/mpid_time.c bgp-mpich2/src/mpid/dcmf/src/misc/mpid_time.c 0a1,43 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file src/misc/mpid_time.c > * \brief Devince interface between MPI_Wtime() and DCMF_Timer() > */ > #include "mpidimpl.h" > > #if MPICH_TIMER_KIND != USE_DEVICE > #error "Not using USE_BG_TIMEBASE" > #endif > > > void MPID_Wtime( MPID_Time_t *tval ) > { > *tval = DCMF_Timer(); > } > double MPID_Wtick() > { > return DCMF_Tick(); > } > void MPID_Wtime_diff( MPID_Time_t *t1, MPID_Time_t *t2, double *diff ) > { > *diff = *t2 - *t1; > } > void MPID_Wtime_todouble( MPID_Time_t *t, double *val ) > { > *val = *t; > } > void MPID_Wtime_acc( MPID_Time_t *t1, MPID_Time_t *t2, MPID_Time_t *t3 ) > { > *t3 += *t1 - *t2; > } > void MPID_Wtime_init() > { > /* We used to call DCMF_Timer() here, but the messager wasn't created yet */ > } diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/misc/mpid_vc.c bgp-mpich2/src/mpid/dcmf/src/misc/mpid_vc.c 0a1,133 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file src/misc/mpid_vc.c > * \brief Maintain the virtual connection reference table > */ > /* -*- Mode: C; c-basic-offset:4 ; -*- */ > /* > * (C) 2001 by Argonne National Laboratory. > * See COPYRIGHT in top-level directory. > */ > > #include "mpidimpl.h" > > /** > * \brief Virtual connection reference table > */ > typedef struct MPIDI_VCRT > { > int handle; /**< This element is not used, but exists so that we may use the MPIU_Object routines for reference counting */ > volatile int ref_count; /**< Number of references to this table */ > int size; /**< Number of entries inthe table */ > MPIDI_VC * vcr_table[1]; /**< array of virtual connection references */ > } > MPIDI_VCRT; > > > int MPID_VCR_Dup(MPID_VCR orig_vcr, MPID_VCR * new_vcr) > { > MPIDI_STATE_DECL(MPID_STATE_MPID_VCR_DUP); > > MPIDI_FUNC_ENTER(MPID_STATE_MPID_VCR_DUP); > MPIU_Object_add_ref(orig_vcr); > *new_vcr = orig_vcr; > MPIDI_FUNC_EXIT(MPID_STATE_MPID_VCR_DUP); > return MPI_SUCCESS; > } > > int MPID_VCR_Release(MPID_VCR vcr) > { > int count; > MPIDI_STATE_DECL(MPID_STATE_MPID_VCR_RELEASE); > > MPIDI_FUNC_ENTER(MPID_STATE_MPID_VCR_RELEASE); > MPIU_Object_release_ref(vcr, &count); > /* FIXME: if necessary, update number of active VCs in the VC table */ > MPIDI_FUNC_EXIT(MPID_STATE_MPID_VCR_RELEASE); > return MPI_SUCCESS; > } > > int MPID_VCR_Get_lpid(MPID_VCR vcr, int * lpid_ptr) > { > MPIDI_STATE_DECL(MPID_STATE_MPID_VCR_GET_LPID); > > MPIDI_FUNC_ENTER(MPID_STATE_MPID_VCR_GET_LPID); > *lpid_ptr = vcr->lpid; > MPIDI_FUNC_EXIT(MPID_STATE_MPID_VCR_GET_LPID); > return MPI_SUCCESS; > } > > > int MPID_VCRT_Create(int size, MPID_VCRT *vcrt_ptr) > { > MPIDI_VCRT * vcrt; > int result; > MPIDI_STATE_DECL(MPID_STATE_MPID_VCRT_CREATE); > > MPIDI_FUNC_ENTER(MPID_STATE_MPID_VCRT_CREATE); > > vcrt = MPIU_Malloc(sizeof(MPIDI_VCRT) + (size - 1) * sizeof(MPIDI_VC)); > if (vcrt != NULL) > { > MPIU_Object_set_ref(vcrt, 1); > vcrt->size = size; > *vcrt_ptr = vcrt; > result = MPI_SUCCESS; > } > else > { > result = MPIR_ERR_MEMALLOCFAILED; > } > MPIDI_FUNC_EXIT(MPID_STATE_MPID_VCRT_CREATE); > return result; > } > > int MPID_VCRT_Add_ref(MPID_VCRT vcrt) > { > MPIDI_STATE_DECL(MPID_STATE_MPID_VCRT_ADD_REF); > > MPIDI_FUNC_ENTER(MPID_STATE_MPID_VCRT_ADD_REF); > MPIU_Object_add_ref(vcrt); > MPIDI_FUNC_EXIT(MPID_STATE_MPID_VCRT_ADD_REF); > return MPI_SUCCESS; > } > > int MPID_VCRT_Release(MPID_VCRT vcrt, int isDisconnect) > { > int count; > MPIDI_STATE_DECL(MPID_STATE_MPID_VCRT_RELEASE); > > MPIDI_FUNC_ENTER(MPID_STATE_MPID_VCRT_RELEASE); > > MPIU_Object_release_ref(vcrt, &count); > if (count == 0) > { > int i; > > for (i = 0; i < vcrt->size; i++) > { > MPID_VCR_Release(vcrt->vcr_table[i]); > } > > MPIU_Free(vcrt); > } > MPIDI_FUNC_EXIT(MPID_STATE_MPID_VCRT_RELEASE); > return MPI_SUCCESS; > } > > int MPID_VCRT_Get_ptr(MPID_VCRT vcrt, MPID_VCR **vc_pptr) > { > MPIDI_STATE_DECL(MPID_STATE_MPID_VCRT_GET_PTR); > > MPIDI_FUNC_ENTER(MPID_STATE_MPID_VCRT_GET_PTR); > *vc_pptr = vcrt->vcr_table; > MPIDI_FUNC_EXIT(MPID_STATE_MPID_VCRT_GET_PTR); > return MPI_SUCCESS; > } diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/misc/mpix.c bgp-mpich2/src/mpid/dcmf/src/misc/mpix.c 0a1,183 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file src/misc/mpix.c > * \brief Blue Gene extensions to the MPI Spec > */ > > #include "mpidimpl.h" > #include "mpix.h" > > #pragma weak PMI_torus2rank = MPIX_torus2rank > unsigned MPIX_torus2rank (unsigned x, > unsigned y, > unsigned z, > unsigned t) > { > unsigned rank; > int rc = DCMF_Messager_torus2rank(x, y, z, t, &rank); > if(rc == DCMF_SUCCESS) return rank; > else return (unsigned)-1; > } > > #pragma weak PMI_Comm_torus2rank = MPIX_Comm_torus2rank > unsigned MPIX_Comm_torus2rank (MPI_Comm comm, > unsigned x, > unsigned y, > unsigned z, > unsigned t) > { > int rank, worldrank = MPIX_torus2rank(x, y, z, t); > if (comm == MPI_COMM_WORLD) rank = worldrank; > else > { > MPI_Group group_a, worldgroup; > MPI_Comm_group (comm, &group_a); > MPI_Comm_group (MPI_COMM_WORLD, &worldgroup); > MPI_Group_translate_ranks (worldgroup, 1, &worldrank, group_a, &rank); > } > return rank; > } > > #pragma weak PMI_rank2torus = MPIX_rank2torus > void MPIX_rank2torus (unsigned rank, > unsigned *x, > unsigned *y, > unsigned *z, > unsigned *t) > { > DCMF_Messager_rank2torus (rank, x, y, z, t); > } > > #pragma weak PMI_Comm_rank2torus = MPIX_Comm_rank2torus > void MPIX_Comm_rank2torus(MPI_Comm comm, > unsigned rank, > unsigned *x, > unsigned *y, > unsigned *z, > unsigned *t) > { > int worldrank; > if (comm == MPI_COMM_WORLD) worldrank = rank; > else > { > MPI_Group group_a, worldgroup; > MPI_Comm_group (comm, &group_a); > MPI_Comm_group (MPI_COMM_WORLD, &worldgroup); > MPI_Group_translate_ranks (group_a, 1, (int*)&rank, worldgroup, &worldrank); > } > MPIX_rank2torus (worldrank, x, y, z, t); > } > > > /** > * \brief Compare each elemt of two four-element arrays > * \param[in] A The first array > * \param[in] B The first array > * \returns MPI_SUCCESS (does not return on failure) > */ > #define CMP_4(A,B) \ > ({ \ > assert(A[0] == B[0]); \ > assert(A[1] == B[1]); \ > assert(A[2] == B[2]); \ > assert(A[3] == B[3]); \ > MPI_SUCCESS; \ > }) > #pragma weak PMI_Cart_comm_create = MPIX_Cart_comm_create > int MPIX_Cart_comm_create(MPI_Comm *cart_comm) > { > int result; > int rank, numprocs, > dims[4], > wrap[4], > coords[4]; > int new_rank, > new_dims[4], > new_wrap[4], > new_coords[4]; > DCMF_Hardware_t pers; > > > *cart_comm = MPI_COMM_NULL; > MPI_Comm_rank(MPI_COMM_WORLD, &rank); > MPI_Comm_size(MPI_COMM_WORLD, &numprocs); > DCMF_Hardware(&pers); > > > dims[3] = pers.xSize; > dims[2] = pers.ySize; > dims[1] = pers.zSize; > dims[0] = pers.tSize; > > /* This only works if MPI_COMM_WORLD is the full partition */ > if (dims[3] * dims[2] * dims[1] * dims[0] != numprocs) > return MPI_ERR_TOPOLOGY; > > wrap[3] = pers.xTorus; > wrap[2] = pers.yTorus; > wrap[1] = pers.zTorus; > wrap[0] = pers.tTorus; > > coords[3] = pers.xCoord; > coords[2] = pers.yCoord; > coords[1] = pers.zCoord; > coords[0] = pers.tCoord; > > > result = MPI_Cart_create( > MPI_COMM_WORLD, > 4, > dims, > wrap, > 0, > cart_comm > ); > if (result != MPI_SUCCESS) return result; > > > MPI_Comm_rank(*cart_comm, &new_rank); > MPI_Cart_get (*cart_comm, 4, new_dims, new_wrap, new_coords); > > CMP_4(dims, new_dims); > CMP_4(wrap, new_wrap); > CMP_4(coords, new_coords); > > return MPI_SUCCESS; > } > > #pragma weak PMI_Pset_same_comm_create = MPIX_Pset_same_comm_create > int MPIX_Pset_same_comm_create(MPI_Comm *pset_comm) > { > int key, color; > DCMF_Hardware_t pers; > > DCMF_Hardware(&pers); > /* All items of the same color are grouped in the same communicator */ > color = pers.idOfPset; > /* The key implies the new rank */ > key = pers.rankInPset*pers.tSize + pers.tCoord; > > return MPI_Comm_split(MPI_COMM_WORLD, color, key, pset_comm); > } > > #pragma weak PMI_Pset_diff_comm_create = MPIX_Pset_diff_comm_create > int MPIX_Pset_diff_comm_create(MPI_Comm *pset_comm) > { > int key, color; > DCMF_Hardware_t pers; > > DCMF_Hardware(&pers); > /* The key implies the new rank */ > key = pers.idOfPset; > /* All items of the same color are grouped in the same communicator */ > color = pers.rankInPset*pers.tSize + pers.tCoord; > > return MPI_Comm_split(MPI_COMM_WORLD, color, key, pset_comm); > } diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/onesided/Doxyfile bgp-mpich2/src/mpid/dcmf/src/onesided/Doxyfile 0a1,1259 > # Doxyfile 1.4.7-20060809 > > # This file describes the settings to be used by the documentation system > # doxygen (www.doxygen.org) for a project > # > # All text after a hash (#) is considered a comment and will be ignored > # The format is: > # TAG = value [value, ...] > # For lists items can also be appended using: > # TAG += value [value, ...] > # Values that contain spaces should be placed between quotes (" ") > > #--------------------------------------------------------------------------- > # Project related configuration options > #--------------------------------------------------------------------------- > > # The PROJECT_NAME tag is a single word (or a sequence of words surrounded > # by quotes) that should identify the project. > > PROJECT_NAME = > > # The PROJECT_NUMBER tag can be used to enter a project or revision number. > # This could be handy for archiving the generated documentation or > # if some version control system is used. > > PROJECT_NUMBER = > > # The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) > # base path where the generated documentation will be put. > # If a relative path is entered, it will be relative to the location > # where doxygen was started. If left blank the current directory will be used. > > OUTPUT_DIRECTORY = /home/dougmill/.doxygen > > # If the CREATE_SUBDIRS tag is set to YES, then doxygen will create > # 4096 sub-directories (in 2 levels) under the output directory of each output > # format and will distribute the generated files over these directories. > # Enabling this option can be useful when feeding doxygen a huge amount of > # source files, where putting all generated files in the same directory would > # otherwise cause performance problems for the file system. > > CREATE_SUBDIRS = NO > > # The OUTPUT_LANGUAGE tag is used to specify the language in which all > # documentation generated by doxygen is written. Doxygen will use this > # information to generate all constant output in the proper language. > # The default language is English, other supported languages are: > # Afrikaans, Arabic, Brazilian, Catalan, Chinese, Chinese-Traditional, > # Croatian, Czech, Danish, Dutch, Finnish, French, German, Greek, Hungarian, > # Italian, Japanese, Japanese-en (Japanese with English messages), Korean, > # Korean-en, Lithuanian, Norwegian, Polish, Portuguese, Romanian, Russian, > # Serbian, Slovak, Slovene, Spanish, Swedish, and Ukrainian. > > OUTPUT_LANGUAGE = English > > # This tag can be used to specify the encoding used in the generated output. > # The encoding is not always determined by the language that is chosen, > # but also whether or not the output is meant for Windows or non-Windows users. > # In case there is a difference, setting the USE_WINDOWS_ENCODING tag to YES > # forces the Windows encoding (this is the default for the Windows binary), > # whereas setting the tag to NO uses a Unix-style encoding (the default for > # all platforms other than Windows). > > USE_WINDOWS_ENCODING = NO > > # If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will > # include brief member descriptions after the members that are listed in > # the file and class documentation (similar to JavaDoc). > # Set to NO to disable this. > > BRIEF_MEMBER_DESC = YES > > # If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will prepend > # the brief description of a member or function before the detailed description. > # Note: if both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the > # brief descriptions will be completely suppressed. > > REPEAT_BRIEF = YES > > # This tag implements a quasi-intelligent brief description abbreviator > # that is used to form the text in various listings. Each string > # in this list, if found as the leading text of the brief description, will be > # stripped from the text and the result after processing the whole list, is > # used as the annotated text. Otherwise, the brief description is used as-is. > # If left blank, the following values are used ("$name" is automatically > # replaced with the name of the entity): "The $name class" "The $name widget" > # "The $name file" "is" "provides" "specifies" "contains" > # "represents" "a" "an" "the" > > ABBREVIATE_BRIEF = > > # If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then > # Doxygen will generate a detailed section even if there is only a brief > # description. > > ALWAYS_DETAILED_SEC = NO > > # If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all > # inherited members of a class in the documentation of that class as if those > # members were ordinary class members. Constructors, destructors and assignment > # operators of the base classes will not be shown. > > INLINE_INHERITED_MEMB = NO > > # If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full > # path before files name in the file list and in the header files. If set > # to NO the shortest path that makes the file name unique will be used. > > FULL_PATH_NAMES = NO > > # If the FULL_PATH_NAMES tag is set to YES then the STRIP_FROM_PATH tag > # can be used to strip a user-defined part of the path. Stripping is > # only done if one of the specified strings matches the left-hand part of > # the path. The tag can be used to show relative paths in the file list. > # If left blank the directory from which doxygen is run is used as the > # path to strip. > > STRIP_FROM_PATH = > > # The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of > # the path mentioned in the documentation of a class, which tells > # the reader which header file to include in order to use a class. > # If left blank only the name of the header file containing the class > # definition is used. Otherwise one should specify the include paths that > # are normally passed to the compiler using the -I flag. > > STRIP_FROM_INC_PATH = > > # If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter > # (but less readable) file names. This can be useful is your file systems > # doesn't support long names like on DOS, Mac, or CD-ROM. > > SHORT_NAMES = NO > > # If the JAVADOC_AUTOBRIEF tag is set to YES then Doxygen > # will interpret the first line (until the first dot) of a JavaDoc-style > # comment as the brief description. If set to NO, the JavaDoc > # comments will behave just like the Qt-style comments (thus requiring an > # explicit @brief command for a brief description. > > JAVADOC_AUTOBRIEF = NO > > # The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make Doxygen > # treat a multi-line C++ special comment block (i.e. a block of //! or /// > # comments) as a brief description. This used to be the default behaviour. > # The new default is to treat a multi-line C++ comment block as a detailed > # description. Set this tag to YES if you prefer the old behaviour instead. > > MULTILINE_CPP_IS_BRIEF = NO > > # If the DETAILS_AT_TOP tag is set to YES then Doxygen > # will output the detailed description near the top, like JavaDoc. > # If set to NO, the detailed description appears after the member > # documentation. > > DETAILS_AT_TOP = NO > > # If the INHERIT_DOCS tag is set to YES (the default) then an undocumented > # member inherits the documentation from any documented member that it > # re-implements. > > INHERIT_DOCS = YES > > # If the SEPARATE_MEMBER_PAGES tag is set to YES, then doxygen will produce > # a new page for each member. If set to NO, the documentation of a member will > # be part of the file/class/namespace that contains it. > > SEPARATE_MEMBER_PAGES = NO > > # The TAB_SIZE tag can be used to set the number of spaces in a tab. > # Doxygen uses this value to replace tabs by spaces in code fragments. > > TAB_SIZE = 8 > > # This tag can be used to specify a number of aliases that acts > # as commands in the documentation. An alias has the form "name=value". > # For example adding "sideeffect=\par Side Effects:\n" will allow you to > # put the command \sideeffect (or @sideeffect) in the documentation, which > # will result in a user-defined paragraph with heading "Side Effects:". > # You can put \n's in the value part of an alias to insert newlines. > > ALIASES = > > # Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C > # sources only. Doxygen will then generate output that is more tailored for C. > # For instance, some of the names that are used will be different. The list > # of all members will be omitted, etc. > > OPTIMIZE_OUTPUT_FOR_C = YES > > # Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java > # sources only. Doxygen will then generate output that is more tailored for Java. > # For instance, namespaces will be presented as packages, qualified scopes > # will look different, etc. > > OPTIMIZE_OUTPUT_JAVA = NO > > # If you use STL classes (i.e. std::string, std::vector, etc.) but do not want to > # include (a tag file for) the STL sources as input, then you should > # set this tag to YES in order to let doxygen match functions declarations and > # definitions whose arguments contain STL classes (e.g. func(std::string); v.s. > # func(std::string) {}). This also make the inheritance and collaboration > # diagrams that involve STL classes more complete and accurate. > > BUILTIN_STL_SUPPORT = NO > > # If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC > # tag is set to YES, then doxygen will reuse the documentation of the first > # member in the group (if any) for the other members of the group. By default > # all members of a group must be documented explicitly. > > DISTRIBUTE_GROUP_DOC = YES > > # Set the SUBGROUPING tag to YES (the default) to allow class member groups of > # the same type (for instance a group of public functions) to be put as a > # subgroup of that type (e.g. under the Public Functions section). Set it to > # NO to prevent subgrouping. Alternatively, this can be done per class using > # the \nosubgrouping command. > > SUBGROUPING = YES > > #--------------------------------------------------------------------------- > # Build related configuration options > #--------------------------------------------------------------------------- > > # If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in > # documentation are documented, even if no documentation was available. > # Private class members and static file members will be hidden unless > # the EXTRACT_PRIVATE and EXTRACT_STATIC tags are set to YES > > EXTRACT_ALL = NO > > # If the EXTRACT_PRIVATE tag is set to YES all private members of a class > # will be included in the documentation. > > EXTRACT_PRIVATE = NO > > # If the EXTRACT_STATIC tag is set to YES all static members of a file > # will be included in the documentation. > > EXTRACT_STATIC = YES > > # If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs) > # defined locally in source files will be included in the documentation. > # If set to NO only classes defined in header files are included. > > EXTRACT_LOCAL_CLASSES = YES > > # This flag is only useful for Objective-C code. When set to YES local > # methods, which are defined in the implementation section but not in > # the interface are included in the documentation. > # If set to NO (the default) only methods in the interface are included. > > EXTRACT_LOCAL_METHODS = NO > > # If the HIDE_UNDOC_MEMBERS tag is set to YES, Doxygen will hide all > # undocumented members of documented classes, files or namespaces. > # If set to NO (the default) these members will be included in the > # various overviews, but no documentation section is generated. > # This option has no effect if EXTRACT_ALL is enabled. > > HIDE_UNDOC_MEMBERS = NO > > # If the HIDE_UNDOC_CLASSES tag is set to YES, Doxygen will hide all > # undocumented classes that are normally visible in the class hierarchy. > # If set to NO (the default) these classes will be included in the various > # overviews. This option has no effect if EXTRACT_ALL is enabled. > > HIDE_UNDOC_CLASSES = NO > > # If the HIDE_FRIEND_COMPOUNDS tag is set to YES, Doxygen will hide all > # friend (class|struct|union) declarations. > # If set to NO (the default) these declarations will be included in the > # documentation. > > HIDE_FRIEND_COMPOUNDS = NO > > # If the HIDE_IN_BODY_DOCS tag is set to YES, Doxygen will hide any > # documentation blocks found inside the body of a function. > # If set to NO (the default) these blocks will be appended to the > # function's detailed documentation block. > > HIDE_IN_BODY_DOCS = NO > > # The INTERNAL_DOCS tag determines if documentation > # that is typed after a \internal command is included. If the tag is set > # to NO (the default) then the documentation will be excluded. > # Set it to YES to include the internal documentation. > > INTERNAL_DOCS = NO > > # If the CASE_SENSE_NAMES tag is set to NO then Doxygen will only generate > # file names in lower-case letters. If set to YES upper-case letters are also > # allowed. This is useful if you have classes or files whose names only differ > # in case and if your file system supports case sensitive file names. Windows > # and Mac users are advised to set this option to NO. > > CASE_SENSE_NAMES = YES > > # If the HIDE_SCOPE_NAMES tag is set to NO (the default) then Doxygen > # will show members with their full class and namespace scopes in the > # documentation. If set to YES the scope will be hidden. > > HIDE_SCOPE_NAMES = NO > > # If the SHOW_INCLUDE_FILES tag is set to YES (the default) then Doxygen > # will put a list of the files that are included by a file in the documentation > # of that file. > > SHOW_INCLUDE_FILES = YES > > # If the INLINE_INFO tag is set to YES (the default) then a tag [inline] > # is inserted in the documentation for inline members. > > INLINE_INFO = YES > > # If the SORT_MEMBER_DOCS tag is set to YES (the default) then doxygen > # will sort the (detailed) documentation of file and class members > # alphabetically by member name. If set to NO the members will appear in > # declaration order. > > SORT_MEMBER_DOCS = NO > > # If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the > # brief documentation of file, namespace and class members alphabetically > # by member name. If set to NO (the default) the members will appear in > # declaration order. > > SORT_BRIEF_DOCS = NO > > # If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be > # sorted by fully-qualified names, including namespaces. If set to > # NO (the default), the class list will be sorted only by class name, > # not including the namespace part. > # Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES. > # Note: This option applies only to the class list, not to the > # alphabetical list. > > SORT_BY_SCOPE_NAME = NO > > # The GENERATE_TODOLIST tag can be used to enable (YES) or > # disable (NO) the todo list. This list is created by putting \todo > # commands in the documentation. > > GENERATE_TODOLIST = YES > > # The GENERATE_TESTLIST tag can be used to enable (YES) or > # disable (NO) the test list. This list is created by putting \test > # commands in the documentation. > > GENERATE_TESTLIST = YES > > # The GENERATE_BUGLIST tag can be used to enable (YES) or > # disable (NO) the bug list. This list is created by putting \bug > # commands in the documentation. > > GENERATE_BUGLIST = YES > > # The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or > # disable (NO) the deprecated list. This list is created by putting > # \deprecated commands in the documentation. > > GENERATE_DEPRECATEDLIST= YES > > # The ENABLED_SECTIONS tag can be used to enable conditional > # documentation sections, marked by \if sectionname ... \endif. > > ENABLED_SECTIONS = > > # The MAX_INITIALIZER_LINES tag determines the maximum number of lines > # the initial value of a variable or define consists of for it to appear in > # the documentation. If the initializer consists of more lines than specified > # here it will be hidden. Use a value of 0 to hide initializers completely. > # The appearance of the initializer of individual variables and defines in the > # documentation can be controlled using \showinitializer or \hideinitializer > # command in the documentation regardless of this setting. > > MAX_INITIALIZER_LINES = 30 > > # Set the SHOW_USED_FILES tag to NO to disable the list of files generated > # at the bottom of the documentation of classes and structs. If set to YES the > # list will mention the files that were used to generate the documentation. > > SHOW_USED_FILES = YES > > # If the sources in your project are distributed over multiple directories > # then setting the SHOW_DIRECTORIES tag to YES will show the directory hierarchy > # in the documentation. The default is NO. > > SHOW_DIRECTORIES = NO > > # The FILE_VERSION_FILTER tag can be used to specify a program or script that > # doxygen should invoke to get the current version for each file (typically from the > # version control system). Doxygen will invoke the program by executing (via > # popen()) the command , where is the value of > # the FILE_VERSION_FILTER tag, and is the name of an input file > # provided by doxygen. Whatever the program writes to standard output > # is used as the file version. See the manual for examples. > > FILE_VERSION_FILTER = > > #--------------------------------------------------------------------------- > # configuration options related to warning and progress messages > #--------------------------------------------------------------------------- > > # The QUIET tag can be used to turn on/off the messages that are generated > # by doxygen. Possible values are YES and NO. If left blank NO is used. > > QUIET = NO > > # The WARNINGS tag can be used to turn on/off the warning messages that are > # generated by doxygen. Possible values are YES and NO. If left blank > # NO is used. > > WARNINGS = YES > > # If WARN_IF_UNDOCUMENTED is set to YES, then doxygen will generate warnings > # for undocumented members. If EXTRACT_ALL is set to YES then this flag will > # automatically be disabled. > > WARN_IF_UNDOCUMENTED = YES > > # If WARN_IF_DOC_ERROR is set to YES, doxygen will generate warnings for > # potential errors in the documentation, such as not documenting some > # parameters in a documented function, or documenting parameters that > # don't exist or using markup commands wrongly. > > WARN_IF_DOC_ERROR = YES > > # This WARN_NO_PARAMDOC option can be abled to get warnings for > # functions that are documented, but have no documentation for their parameters > # or return value. If set to NO (the default) doxygen will only warn about > # wrong or incomplete parameter documentation, but not about the absence of > # documentation. > > WARN_NO_PARAMDOC = YES > > # The WARN_FORMAT tag determines the format of the warning messages that > # doxygen can produce. The string should contain the $file, $line, and $text > # tags, which will be replaced by the file and line number from which the > # warning originated and the warning text. Optionally the format may contain > # $version, which will be replaced by the version of the file (if it could > # be obtained via FILE_VERSION_FILTER) > > WARN_FORMAT = "$file:$line: $text" > > # The WARN_LOGFILE tag can be used to specify a file to which warning > # and error messages should be written. If left blank the output is written > # to stderr. > > WARN_LOGFILE = > > #--------------------------------------------------------------------------- > # configuration options related to the input files > #--------------------------------------------------------------------------- > > # The INPUT tag can be used to specify the files and/or directories that contain > # documented source files. You may enter file names like "myfile.cpp" or > # directories like "/usr/src/myproject". Separate the files or directories > # with spaces. > > INPUT = mpid_onesided.c ../../include/mpidpre.h > > # If the value of the INPUT tag contains directories, you can use the > # FILE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp > # and *.h) to filter out the source-files in the directories. If left > # blank the following patterns are tested: > # *.c *.cc *.cxx *.cpp *.c++ *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh *.hxx > # *.hpp *.h++ *.idl *.odl *.cs *.php *.php3 *.inc *.m *.mm *.py > > FILE_PATTERNS = > > # The RECURSIVE tag can be used to turn specify whether or not subdirectories > # should be searched for input files as well. Possible values are YES and NO. > # If left blank NO is used. > > RECURSIVE = YES > > # The EXCLUDE tag can be used to specify files and/or directories that should > # excluded from the INPUT source files. This way you can easily exclude a > # subdirectory from a directory tree whose root is specified with the INPUT tag. > > EXCLUDE = CVS > > # The EXCLUDE_SYMLINKS tag can be used select whether or not files or > # directories that are symbolic links (a Unix filesystem feature) are excluded > # from the input. > > EXCLUDE_SYMLINKS = NO > > # If the value of the INPUT tag contains directories, you can use the > # EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude > # certain files from those directories. Note that the wildcards are matched > # against the file with absolute path, so to exclude all test directories > # for example use the pattern */test/* > > EXCLUDE_PATTERNS = > > # The EXAMPLE_PATH tag can be used to specify one or more files or > # directories that contain example code fragments that are included (see > # the \include command). > > EXAMPLE_PATH = > > # If the value of the EXAMPLE_PATH tag contains directories, you can use the > # EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp > # and *.h) to filter out the source-files in the directories. If left > # blank all files are included. > > EXAMPLE_PATTERNS = > > # If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be > # searched for input files to be used with the \include or \dontinclude > # commands irrespective of the value of the RECURSIVE tag. > # Possible values are YES and NO. If left blank NO is used. > > EXAMPLE_RECURSIVE = NO > > # The IMAGE_PATH tag can be used to specify one or more files or > # directories that contain image that are included in the documentation (see > # the \image command). > > IMAGE_PATH = > > # The INPUT_FILTER tag can be used to specify a program that doxygen should > # invoke to filter for each input file. Doxygen will invoke the filter program > # by executing (via popen()) the command , where > # is the value of the INPUT_FILTER tag, and is the name of an > # input file. Doxygen will then use the output that the filter program writes > # to standard output. If FILTER_PATTERNS is specified, this tag will be > # ignored. > > INPUT_FILTER = > > # The FILTER_PATTERNS tag can be used to specify filters on a per file pattern > # basis. Doxygen will compare the file name with each pattern and apply the > # filter if there is a match. The filters are a list of the form: > # pattern=filter (like *.cpp=my_cpp_filter). See INPUT_FILTER for further > # info on how filters are used. If FILTER_PATTERNS is empty, INPUT_FILTER > # is applied to all files. > > FILTER_PATTERNS = > > # If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using > # INPUT_FILTER) will be used to filter the input files when producing source > # files to browse (i.e. when SOURCE_BROWSER is set to YES). > > FILTER_SOURCE_FILES = NO > > #--------------------------------------------------------------------------- > # configuration options related to source browsing > #--------------------------------------------------------------------------- > > # If the SOURCE_BROWSER tag is set to YES then a list of source files will > # be generated. Documented entities will be cross-referenced with these sources. > # Note: To get rid of all source code in the generated output, make sure also > # VERBATIM_HEADERS is set to NO. > > SOURCE_BROWSER = YES > > # Setting the INLINE_SOURCES tag to YES will include the body > # of functions and classes directly in the documentation. > > INLINE_SOURCES = YES > > # Setting the STRIP_CODE_COMMENTS tag to YES (the default) will instruct > # doxygen to hide any special comment blocks from generated source code > # fragments. Normal C and C++ comments will always remain visible. > > #STRIP_CODE_COMMENTS = YES > STRIP_CODE_COMMENTS = YES > > # If the REFERENCED_BY_RELATION tag is set to YES (the default) > # then for each documented function all documented > # functions referencing it will be listed. > > REFERENCED_BY_RELATION = YES > > # If the REFERENCES_RELATION tag is set to YES (the default) > # then for each documented function all documented entities > # called/used by that function will be listed. > > REFERENCES_RELATION = YES > > # If the REFERENCES_LINK_SOURCE tag is set to YES (the default) > # and SOURCE_BROWSER tag is set to YES, then the hyperlinks from > # functions in REFERENCES_RELATION and REFERENCED_BY_RELATION lists will > # link to the source code. Otherwise they will link to the documentstion. > > REFERENCES_LINK_SOURCE = YES > > # If the USE_HTAGS tag is set to YES then the references to source code > # will point to the HTML generated by the htags(1) tool instead of doxygen > # built-in source browser. The htags tool is part of GNU's global source > # tagging system (see http://www.gnu.org/software/global/global.html). You > # will need version 4.8.6 or higher. > > USE_HTAGS = NO > > # If the VERBATIM_HEADERS tag is set to YES (the default) then Doxygen > # will generate a verbatim copy of the header file for each class for > # which an include is specified. Set to NO to disable this. > > #VERBATIM_HEADERS = YES > VERBATIM_HEADERS = NO > > #--------------------------------------------------------------------------- > # configuration options related to the alphabetical class index > #--------------------------------------------------------------------------- > > # If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index > # of all compounds will be generated. Enable this if the project > # contains a lot of classes, structs, unions or interfaces. > > ALPHABETICAL_INDEX = NO > > # If the alphabetical index is enabled (see ALPHABETICAL_INDEX) then > # the COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns > # in which this list will be split (can be a number in the range [1..20]) > > COLS_IN_ALPHA_INDEX = 5 > > # In case all classes in a project start with a common prefix, all > # classes will be put under the same header in the alphabetical index. > # The IGNORE_PREFIX tag can be used to specify one or more prefixes that > # should be ignored while generating the index headers. > > IGNORE_PREFIX = > > #--------------------------------------------------------------------------- > # configuration options related to the HTML output > #--------------------------------------------------------------------------- > > # If the GENERATE_HTML tag is set to YES (the default) Doxygen will > # generate HTML output. > > GENERATE_HTML = YES > > # The HTML_OUTPUT tag is used to specify where the HTML docs will be put. > # If a relative path is entered the value of OUTPUT_DIRECTORY will be > # put in front of it. If left blank `html' will be used as the default path. > > HTML_OUTPUT = html > > # The HTML_FILE_EXTENSION tag can be used to specify the file extension for > # each generated HTML page (for example: .htm,.php,.asp). If it is left blank > # doxygen will generate files with .html extension. > > HTML_FILE_EXTENSION = .html > > # The HTML_HEADER tag can be used to specify a personal HTML header for > # each generated HTML page. If it is left blank doxygen will generate a > # standard header. > > HTML_HEADER = > > # The HTML_FOOTER tag can be used to specify a personal HTML footer for > # each generated HTML page. If it is left blank doxygen will generate a > # standard footer. > > HTML_FOOTER = > > # The HTML_STYLESHEET tag can be used to specify a user-defined cascading > # style sheet that is used by each HTML page. It can be used to > # fine-tune the look of the HTML output. If the tag is left blank doxygen > # will generate a default style sheet. Note that doxygen will try to copy > # the style sheet file to the HTML output directory, so don't put your own > # stylesheet in the HTML output directory as well, or it will be erased! > > HTML_STYLESHEET = > > # If the HTML_ALIGN_MEMBERS tag is set to YES, the members of classes, > # files or namespaces will be aligned in HTML using tables. If set to > # NO a bullet list will be used. > > HTML_ALIGN_MEMBERS = YES > #HTML_ALIGN_MEMBERS = NO > > # If the GENERATE_HTMLHELP tag is set to YES, additional index files > # will be generated that can be used as input for tools like the > # Microsoft HTML help workshop to generate a compressed HTML help file (.chm) > # of the generated HTML documentation. > > GENERATE_HTMLHELP = NO > > # If the GENERATE_HTMLHELP tag is set to YES, the CHM_FILE tag can > # be used to specify the file name of the resulting .chm file. You > # can add a path in front of the file if the result should not be > # written to the html output directory. > > CHM_FILE = > > # If the GENERATE_HTMLHELP tag is set to YES, the HHC_LOCATION tag can > # be used to specify the location (absolute path including file name) of > # the HTML help compiler (hhc.exe). If non-empty doxygen will try to run > # the HTML help compiler on the generated index.hhp. > > HHC_LOCATION = > > # If the GENERATE_HTMLHELP tag is set to YES, the GENERATE_CHI flag > # controls if a separate .chi index file is generated (YES) or that > # it should be included in the master .chm file (NO). > > GENERATE_CHI = NO > > # If the GENERATE_HTMLHELP tag is set to YES, the BINARY_TOC flag > # controls whether a binary table of contents is generated (YES) or a > # normal table of contents (NO) in the .chm file. > > BINARY_TOC = NO > > # The TOC_EXPAND flag can be set to YES to add extra items for group members > # to the contents of the HTML help documentation and to the tree view. > > TOC_EXPAND = NO > > # The DISABLE_INDEX tag can be used to turn on/off the condensed index at > # top of each HTML page. The value NO (the default) enables the index and > # the value YES disables it. > > DISABLE_INDEX = NO > > # This tag can be used to set the number of enum values (range [1..20]) > # that doxygen will group on one line in the generated HTML documentation. > > ENUM_VALUES_PER_LINE = 4 > > # If the GENERATE_TREEVIEW tag is set to YES, a side panel will be > # generated containing a tree-like index structure (just like the one that > # is generated for HTML Help). For this to work a browser that supports > # JavaScript, DHTML, CSS and frames is required (for instance Mozilla 1.0+, > # Netscape 6.0+, Internet explorer 5.0+, or Konqueror). Windows users are > # probably better off using the HTML help feature. > > GENERATE_TREEVIEW = NO > > # If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be > # used to set the initial width (in pixels) of the frame in which the tree > # is shown. > > TREEVIEW_WIDTH = 250 > > #--------------------------------------------------------------------------- > # configuration options related to the LaTeX output > #--------------------------------------------------------------------------- > > # If the GENERATE_LATEX tag is set to YES (the default) Doxygen will > # generate Latex output. > > GENERATE_LATEX = YES > > # The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put. > # If a relative path is entered the value of OUTPUT_DIRECTORY will be > # put in front of it. If left blank `latex' will be used as the default path. > > LATEX_OUTPUT = latex > > # The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be > # invoked. If left blank `latex' will be used as the default command name. > > LATEX_CMD_NAME = latex > > # The MAKEINDEX_CMD_NAME tag can be used to specify the command name to > # generate index for LaTeX. If left blank `makeindex' will be used as the > # default command name. > > MAKEINDEX_CMD_NAME = makeindex > > # If the COMPACT_LATEX tag is set to YES Doxygen generates more compact > # LaTeX documents. This may be useful for small projects and may help to > # save some trees in general. > > COMPACT_LATEX = NO > > # The PAPER_TYPE tag can be used to set the paper type that is used > # by the printer. Possible values are: a4, a4wide, letter, legal and > # executive. If left blank a4wide will be used. > > PAPER_TYPE = letter > > # The EXTRA_PACKAGES tag can be to specify one or more names of LaTeX > # packages that should be included in the LaTeX output. > > EXTRA_PACKAGES = > > # The LATEX_HEADER tag can be used to specify a personal LaTeX header for > # the generated latex document. The header should contain everything until > # the first chapter. If it is left blank doxygen will generate a > # standard header. Notice: only use this tag if you know what you are doing! > > LATEX_HEADER = > > # If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated > # is prepared for conversion to pdf (using ps2pdf). The pdf file will > # contain links (just like the HTML output) instead of page references > # This makes the output suitable for online browsing using a pdf viewer. > > PDF_HYPERLINKS = YES > > # If the USE_PDFLATEX tag is set to YES, pdflatex will be used instead of > # plain latex in the generated Makefile. Set this option to YES to get a > # higher quality PDF documentation. > > USE_PDFLATEX = YES > > # If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \\batchmode. > # command to the generated LaTeX files. This will instruct LaTeX to keep > # running if errors occur, instead of asking the user for help. > # This option is also used when generating formulas in HTML. > > LATEX_BATCHMODE = NO > > # If LATEX_HIDE_INDICES is set to YES then doxygen will not > # include the index chapters (such as File Index, Compound Index, etc.) > # in the output. > > LATEX_HIDE_INDICES = NO > > #--------------------------------------------------------------------------- > # configuration options related to the RTF output > #--------------------------------------------------------------------------- > > # If the GENERATE_RTF tag is set to YES Doxygen will generate RTF output > # The RTF output is optimized for Word 97 and may not look very pretty with > # other RTF readers or editors. > > GENERATE_RTF = NO > > # The RTF_OUTPUT tag is used to specify where the RTF docs will be put. > # If a relative path is entered the value of OUTPUT_DIRECTORY will be > # put in front of it. If left blank `rtf' will be used as the default path. > > RTF_OUTPUT = rtf > > # If the COMPACT_RTF tag is set to YES Doxygen generates more compact > # RTF documents. This may be useful for small projects and may help to > # save some trees in general. > > COMPACT_RTF = NO > > # If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated > # will contain hyperlink fields. The RTF file will > # contain links (just like the HTML output) instead of page references. > # This makes the output suitable for online browsing using WORD or other > # programs which support those fields. > # Note: wordpad (write) and others do not support links. > > RTF_HYPERLINKS = NO > > # Load stylesheet definitions from file. Syntax is similar to doxygen's > # config file, i.e. a series of assignments. You only have to provide > # replacements, missing definitions are set to their default value. > > RTF_STYLESHEET_FILE = > > # Set optional variables used in the generation of an rtf document. > # Syntax is similar to doxygen's config file. > > RTF_EXTENSIONS_FILE = > > #--------------------------------------------------------------------------- > # configuration options related to the man page output > #--------------------------------------------------------------------------- > > # If the GENERATE_MAN tag is set to YES (the default) Doxygen will > # generate man pages > > GENERATE_MAN = NO > > # The MAN_OUTPUT tag is used to specify where the man pages will be put. > # If a relative path is entered the value of OUTPUT_DIRECTORY will be > # put in front of it. If left blank `man' will be used as the default path. > > MAN_OUTPUT = man > > # The MAN_EXTENSION tag determines the extension that is added to > # the generated man pages (default is the subroutine's section .3) > > MAN_EXTENSION = .3 > > # If the MAN_LINKS tag is set to YES and Doxygen generates man output, > # then it will generate one additional man file for each entity > # documented in the real man page(s). These additional files > # only source the real man page, but without them the man command > # would be unable to find the correct page. The default is NO. > > MAN_LINKS = NO > > #--------------------------------------------------------------------------- > # configuration options related to the XML output > #--------------------------------------------------------------------------- > > # If the GENERATE_XML tag is set to YES Doxygen will > # generate an XML file that captures the structure of > # the code including all documentation. > > GENERATE_XML = NO > > # The XML_OUTPUT tag is used to specify where the XML pages will be put. > # If a relative path is entered the value of OUTPUT_DIRECTORY will be > # put in front of it. If left blank `xml' will be used as the default path. > > XML_OUTPUT = xml > > # The XML_SCHEMA tag can be used to specify an XML schema, > # which can be used by a validating XML parser to check the > # syntax of the XML files. > > XML_SCHEMA = > > # The XML_DTD tag can be used to specify an XML DTD, > # which can be used by a validating XML parser to check the > # syntax of the XML files. > > XML_DTD = > > # If the XML_PROGRAMLISTING tag is set to YES Doxygen will > # dump the program listings (including syntax highlighting > # and cross-referencing information) to the XML output. Note that > # enabling this will significantly increase the size of the XML output. > > XML_PROGRAMLISTING = YES > > #--------------------------------------------------------------------------- > # configuration options for the AutoGen Definitions output > #--------------------------------------------------------------------------- > > # If the GENERATE_AUTOGEN_DEF tag is set to YES Doxygen will > # generate an AutoGen Definitions (see autogen.sf.net) file > # that captures the structure of the code including all > # documentation. Note that this feature is still experimental > # and incomplete at the moment. > > GENERATE_AUTOGEN_DEF = NO > > #--------------------------------------------------------------------------- > # configuration options related to the Perl module output > #--------------------------------------------------------------------------- > > # If the GENERATE_PERLMOD tag is set to YES Doxygen will > # generate a Perl module file that captures the structure of > # the code including all documentation. Note that this > # feature is still experimental and incomplete at the > # moment. > > GENERATE_PERLMOD = NO > > # If the PERLMOD_LATEX tag is set to YES Doxygen will generate > # the necessary Makefile rules, Perl scripts and LaTeX code to be able > # to generate PDF and DVI output from the Perl module output. > > PERLMOD_LATEX = NO > > # If the PERLMOD_PRETTY tag is set to YES the Perl module output will be > # nicely formatted so it can be parsed by a human reader. This is useful > # if you want to understand what is going on. On the other hand, if this > # tag is set to NO the size of the Perl module output will be much smaller > # and Perl will parse it just the same. > > PERLMOD_PRETTY = YES > > # The names of the make variables in the generated doxyrules.make file > # are prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX. > # This is useful so different doxyrules.make files included by the same > # Makefile don't overwrite each other's variables. > > PERLMOD_MAKEVAR_PREFIX = > > #--------------------------------------------------------------------------- > # Configuration options related to the preprocessor > #--------------------------------------------------------------------------- > > # If the ENABLE_PREPROCESSING tag is set to YES (the default) Doxygen will > # evaluate all C-preprocessor directives found in the sources and include > # files. > > ENABLE_PREPROCESSING = YES > > # If the MACRO_EXPANSION tag is set to YES Doxygen will expand all macro > # names in the source code. If set to NO (the default) only conditional > # compilation will be performed. Macro expansion can be done in a controlled > # way by setting EXPAND_ONLY_PREDEF to YES. > > MACRO_EXPANSION = NO > > # If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES > # then the macro expansion is limited to the macros specified with the > # PREDEFINED and EXPAND_AS_DEFINED tags. > > EXPAND_ONLY_PREDEF = NO > > # If the SEARCH_INCLUDES tag is set to YES (the default) the includes files > # in the INCLUDE_PATH (see below) will be search if a #include is found. > > SEARCH_INCLUDES = YES > > # The INCLUDE_PATH tag can be used to specify one or more directories that > # contain include files that are not input files but should be processed by > # the preprocessor. > > INCLUDE_PATH = > > # You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard > # patterns (like *.h and *.hpp) to filter out the header-files in the > # directories. If left blank, the patterns specified with FILE_PATTERNS will > # be used. > > INCLUDE_FILE_PATTERNS = > > # The PREDEFINED tag can be used to specify one or more macro names that > # are defined before the preprocessor is started (similar to the -D option of > # gcc). The argument of the tag is a list of macros of the form: name > # or name=definition (no spaces). If the definition and the = are > # omitted =1 is assumed. To prevent a macro definition from being > # undefined via #undef or recursively expanded use the := operator > # instead of the = operator. > > PREDEFINED = __bgp__ > > # If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then > # this tag can be used to specify a list of macro names that should be expanded. > # The macro definition that is found in the sources will be used. > # Use the PREDEFINED tag if you want to use a different macro definition. > > EXPAND_AS_DEFINED = > > # If the SKIP_FUNCTION_MACROS tag is set to YES (the default) then > # doxygen's preprocessor will remove all function-like macros that are alone > # on a line, have an all uppercase name, and do not end with a semicolon. Such > # function macros are typically used for boiler-plate code, and will confuse > # the parser if not removed. > > SKIP_FUNCTION_MACROS = YES > > #--------------------------------------------------------------------------- > # Configuration::additions related to external references > #--------------------------------------------------------------------------- > > # The TAGFILES option can be used to specify one or more tagfiles. > # Optionally an initial location of the external documentation > # can be added for each tagfile. The format of a tag file without > # this location is as follows: > # TAGFILES = file1 file2 ... > # Adding location for the tag files is done as follows: > # TAGFILES = file1=loc1 "file2 = loc2" ... > # where "loc1" and "loc2" can be relative or absolute paths or > # URLs. If a location is present for each tag, the installdox tool > # does not have to be run to correct the links. > # Note that each tag file must have a unique name > # (where the name does NOT include the path) > # If a tag file is not located in the directory in which doxygen > # is run, you must also specify the path to the tagfile here. > > TAGFILES = > > # When a file name is specified after GENERATE_TAGFILE, doxygen will create > # a tag file that is based on the input files it reads. > > GENERATE_TAGFILE = > > # If the ALLEXTERNALS tag is set to YES all external classes will be listed > # in the class index. If set to NO only the inherited external classes > # will be listed. > > ALLEXTERNALS = NO > > # If the EXTERNAL_GROUPS tag is set to YES all external groups will be listed > # in the modules index. If set to NO, only the current project's groups will > # be listed. > > EXTERNAL_GROUPS = YES > > # The PERL_PATH should be the absolute path and name of the perl script > # interpreter (i.e. the result of `which perl'). > > PERL_PATH = /usr/bin/perl > > #--------------------------------------------------------------------------- > # Configuration options related to the dot tool > #--------------------------------------------------------------------------- > > # If the CLASS_DIAGRAMS tag is set to YES (the default) Doxygen will > # generate a inheritance diagram (in HTML, RTF and LaTeX) for classes with base > # or super classes. Setting the tag to NO turns the diagrams off. Note that > # this option is superseded by the HAVE_DOT option below. This is only a > # fallback. It is recommended to install and use dot, since it yields more > # powerful graphs. > > CLASS_DIAGRAMS = YES > > # If set to YES, the inheritance and collaboration graphs will hide > # inheritance and usage relations if the target is undocumented > # or is not a class. > > HIDE_UNDOC_RELATIONS = YES > > # If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is > # available from the path. This tool is part of Graphviz, a graph visualization > # toolkit from AT&T and Lucent Bell Labs. The other options in this section > # have no effect if this option is set to NO (the default) > > HAVE_DOT = NO > > # If the CLASS_GRAPH and HAVE_DOT tags are set to YES then doxygen > # will generate a graph for each documented class showing the direct and > # indirect inheritance relations. Setting this tag to YES will force the > # the CLASS_DIAGRAMS tag to NO. > > CLASS_GRAPH = YES > > # If the COLLABORATION_GRAPH and HAVE_DOT tags are set to YES then doxygen > # will generate a graph for each documented class showing the direct and > # indirect implementation dependencies (inheritance, containment, and > # class references variables) of the class with other documented classes. > > COLLABORATION_GRAPH = YES > > # If the GROUP_GRAPHS and HAVE_DOT tags are set to YES then doxygen > # will generate a graph for groups, showing the direct groups dependencies > > GROUP_GRAPHS = YES > > # If the UML_LOOK tag is set to YES doxygen will generate inheritance and > # collaboration diagrams in a style similar to the OMG's Unified Modeling > # Language. > > UML_LOOK = NO > > # If set to YES, the inheritance and collaboration graphs will show the > # relations between templates and their instances. > > TEMPLATE_RELATIONS = NO > > # If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDE_GRAPH, and HAVE_DOT > # tags are set to YES then doxygen will generate a graph for each documented > # file showing the direct and indirect include dependencies of the file with > # other documented files. > > INCLUDE_GRAPH = YES > > # If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDED_BY_GRAPH, and > # HAVE_DOT tags are set to YES then doxygen will generate a graph for each > # documented header file showing the documented files that directly or > # indirectly include this file. > > INCLUDED_BY_GRAPH = YES > > # If the CALL_GRAPH and HAVE_DOT tags are set to YES then doxygen will > # generate a call dependency graph for every global function or class method. > # Note that enabling this option will significantly increase the time of a run. > # So in most cases it will be better to enable call graphs for selected > # functions only using the \callgraph command. > > CALL_GRAPH = NO > > # If the CALLER_GRAPH and HAVE_DOT tags are set to YES then doxygen will > # generate a caller dependency graph for every global function or class method. > # Note that enabling this option will significantly increase the time of a run. > # So in most cases it will be better to enable caller graphs for selected > # functions only using the \callergraph command. > > CALLER_GRAPH = NO > > # If the GRAPHICAL_HIERARCHY and HAVE_DOT tags are set to YES then doxygen > # will graphical hierarchy of all classes instead of a textual one. > > GRAPHICAL_HIERARCHY = YES > > # If the DIRECTORY_GRAPH, SHOW_DIRECTORIES and HAVE_DOT tags are set to YES > # then doxygen will show the dependencies a directory has on other directories > # in a graphical way. The dependency relations are determined by the #include > # relations between the files in the directories. > > DIRECTORY_GRAPH = YES > > # The DOT_IMAGE_FORMAT tag can be used to set the image format of the images > # generated by dot. Possible values are png, jpg, or gif > # If left blank png will be used. > > DOT_IMAGE_FORMAT = png > > # The tag DOT_PATH can be used to specify the path where the dot tool can be > # found. If left blank, it is assumed the dot tool can be found in the path. > > DOT_PATH = > > # The DOTFILE_DIRS tag can be used to specify one or more directories that > # contain dot files that are included in the documentation (see the > # \dotfile command). > > DOTFILE_DIRS = > > # The MAX_DOT_GRAPH_WIDTH tag can be used to set the maximum allowed width > # (in pixels) of the graphs generated by dot. If a graph becomes larger than > # this value, doxygen will try to truncate the graph, so that it fits within > # the specified constraint. Beware that most browsers cannot cope with very > # large images. > > MAX_DOT_GRAPH_WIDTH = 1024 > > # The MAX_DOT_GRAPH_HEIGHT tag can be used to set the maximum allows height > # (in pixels) of the graphs generated by dot. If a graph becomes larger than > # this value, doxygen will try to truncate the graph, so that it fits within > # the specified constraint. Beware that most browsers cannot cope with very > # large images. > > MAX_DOT_GRAPH_HEIGHT = 1024 > > # The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the > # graphs generated by dot. A depth value of 3 means that only nodes reachable > # from the root by following a path via at most 3 edges will be shown. Nodes > # that lay further from the root node will be omitted. Note that setting this > # option to 1 or 2 may greatly reduce the computation time needed for large > # code bases. Also note that a graph may be further truncated if the graph's > # image dimensions are not sufficient to fit the graph (see MAX_DOT_GRAPH_WIDTH > # and MAX_DOT_GRAPH_HEIGHT). If 0 is used for the depth value (the default), > # the graph is not depth-constrained. > > MAX_DOT_GRAPH_DEPTH = 0 > > # Set the DOT_TRANSPARENT tag to YES to generate images with a transparent > # background. This is disabled by default, which results in a white background. > # Warning: Depending on the platform used, enabling this option may lead to > # badly anti-aliased labels on the edges of a graph (i.e. they become hard to > # read). > > DOT_TRANSPARENT = NO > > # Set the DOT_MULTI_TARGETS tag to YES allow dot to generate multiple output > # files in one run (i.e. multiple -o and -T options on the command line). This > # makes dot run faster, but since only newer versions of dot (>1.8.10) > # support this, this feature is disabled by default. > > DOT_MULTI_TARGETS = NO > > # If the GENERATE_LEGEND tag is set to YES (the default) Doxygen will > # generate a legend page explaining the meaning of the various boxes and > # arrows in the dot generated graphs. > > GENERATE_LEGEND = YES > > # If the DOT_CLEANUP tag is set to YES (the default) Doxygen will > # remove the intermediate dot files that are used to generate > # the various graphs. > > DOT_CLEANUP = YES > > #--------------------------------------------------------------------------- > # Configuration::additions related to the search engine > #--------------------------------------------------------------------------- > > # The SEARCHENGINE tag specifies whether or not a search engine should be > # used. If set to NO the values of all tags below this one will be ignored. > > SEARCHENGINE = NO > # > #< HIDE_SCOPE_NAMES = NO > #--- > #> HIDE_SCOPE_NAMES = YES diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/onesided/Makefile.sm bgp-mpich2/src/mpid/dcmf/src/onesided/Makefile.sm 0a1,13 > SUBDIRS= . > INCLUDES = -I${master_top_srcdir}/src/include -I${top_builddir}/src/include > lib${MPILIBNAME}_a_SOURCES = \ > mpid_rma_common.c \ > mpid_win_create.c \ > mpid_win_fence.c \ > mpid_win_pscw.c \ > mpid_win_lock.c \ > mpid_put.c \ > mpid_get.c \ > mpid_accumulate.c \ > mpid_misc.c \ > mpid_onesided.h diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/onesided/mpid_accumulate.c bgp-mpich2/src/mpid/dcmf/src/onesided/mpid_accumulate.c 0a1,455 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file src/onesided/mpid_accumulate.c > * \brief MPI-DCMF MPI_Accumulate functionality > */ > > #include "mpid_onesided.h" > > #define DATATYPE_ADDITIONAL(dt) \ > (dt == MPI_FLOAT_INT || \ > dt == MPI_DOUBLE_INT || \ > dt == MPI_LONG_INT || \ > dt == MPI_SHORT_INT || \ > dt == MPI_LONG_DOUBLE_INT) > > #define DATATYPE_PREDEFINED(dt) \ > (HANDLE_GET_KIND(dt) == HANDLE_KIND_BUILTIN || \ > DATATYPE_ADDITIONAL(dt)) > > /** > * \brief Utility routine to provide accumulate function locally. > * > * Utility routine to provide accumulate function locally. > * > * Called from \e target_accumulate(), or \e MPID_Accumulate() in the > * case of local operation (to self). > * > * Non-contiguous datatypes are handled by \e MPID_Accumulate(), > * which splits the data into contiguous regions. Note that MPICH2 > * states that datatypes used with MPI_Accumulate must be "monotonic", > * they must be of only one underlying type. > * > * We have to cast the 'src' param to '(void *)' in our calls to the > * operand function because MPI_User_function is declared without the 'const' > * even though MPID_User_function union elements have the 'const'. > * Also, cxx_call_op_fn is missing the 'const'. Even with that, we still > * have to cast when assigning to uop from op_ptr, because of the way > * f77_function and c_function are declared. > * > * \param[in] win Pointer to MPID_Win object > * \param[in] dst Pointer to destination buffer > * \param[in] src Pointer to source buffer > * \param[in] lpid lpid of origin > * \param[in] dt Local datatype > * \param[in] op Operand > * \param[in] num number of dt elements > * \return nothing > * > */ > static void local_accumulate(MPID_Win *win, char *dst, const char *src, > int lpid, MPI_Datatype dt, MPI_Op op, int num) { > MPI_User_function *uop; > int is_cxx = 0; > > if (HANDLE_GET_KIND(op) == HANDLE_KIND_BUILTIN) { > uop = MPIR_Op_table[op%16 - 1]; > } else { > MPID_Op *op_ptr; > > /* > * This case can only happen if accumulate originated locally. > */ > MPID_Op_get_ptr(op, op_ptr); > if (op_ptr->language == MPID_LANG_C) { > uop = (MPI_User_function *)op_ptr->function.c_function; > #ifdef HAVE_CXX_BINDING > } else if (op_ptr->language == MPID_LANG_CXX) { > uop = (MPI_User_function *)op_ptr->function.c_function; > ++is_cxx; > #endif /* HAVE_CXX_BINDING */ > } else { > uop = (MPI_User_function *)op_ptr->function.f77_function; > } > } > /* MPI_REPLACE was filtered-out in MPID_Accumulate() */ > /* Also, MPID_Accumulate() only passes builtin types to us */ > /* builtin implies contiguous */ > #ifdef HAVE_CXX_BINDING > if (is_cxx) > (*MPIR_Process.cxx_call_op_fn)((void *)src, dst, num, dt, uop); > else > #endif /* HAVE_CXX_BINDING */ > (*uop)((void *)src, dst, &num, &dt); > } > > /** > * \brief Utility routine to provide accumulate function on target. > * > * Utility routine to provide accumulate function on target. > * Updates RMA count. > * > * w0 = MPID_MSGTYPE_ACC (not used) > * w1 = Window handle > * w2 = Rank of origin > * w3 = Destination buffer address > * w4 = "eltype" datatype handle (must be builtin) > * w5 = Operand > * w6 = number of datatype elements > * w7 = (not used) > * > * Called from "long message" ACCUMULATE completion callback > * or "short message" ACCUMULATE receive callback. > * > * \param[in] mi MPIDU_Onesided_info_t for accumulate, as described above > * \param[in] src Pointer to source buffer > * \param[in] lpid lpid of origin > * \return nothing > */ > void target_accumulate(MPIDU_Onesided_info_t *mi, > const char *src, int lpid) { > MPID_Win *win; > > MPID_Win_get_ptr((MPI_Win)mi->mpid_info_w1, win); > MPID_assert_debug(win != NULL); > local_accumulate(win, (char *)mi->mpid_info_w3, src, > mi->mpid_info_w2, mi->mpid_info_w4, mi->mpid_info_w5, mi->mpid_info_w6); > rma_recvs_cb(win, mi->mpid_info_w2, lpid); > } > > /** > * \brief Callback for Accumulate recv completion > * > * "Message receive completion" callback used for MPID_MSGTYPE_ACC > * to implement the accumulate function. Decodes data from request > * cache object, frees request, does accumulate, and updates RMA count. > * > * Used for "long message" ACCUMULATE. > * > * To use this callback, the "xtra" info (DCQuad) must > * be filled as follows: > * > * - \e w0 - ignored > * - \e w1 - ignored > * - \e w2 - (int *)multi-struct buffer (int *, DCQuad[], data) > * - \e w3 - origin lpid > * > * \param[in] v Pointer to DCMF request object > * \return nothing > * > * \ref msginfo_usage > */ > void accum_cb(void *v) { > MPIDU_Onesided_info_t *info; > DCQuad xtra; > char *buf; > > MPIDU_free_req((DCMF_Request_t *)v, &xtra); > info = (MPIDU_Onesided_info_t *)xtra.w2; > buf = (char *)(info + 1); > > target_accumulate(info, buf, xtra.w3); > MPIDU_FREE(info, e, "accum_cb"); > } > > /** > * \page accum_design MPID_Accumulate Design > * > * A MPID_Accumulate sequence is as follows: > * > * Origin node calls MPI_Accumulate > * > * - A sanity-check is done to > * ensure that the window is in a valid state to initiate > * an accumulate RMA operation. > * These checks include testing that > * the epoch currently in affect is not \e NONE or \e POST. > * Additionally, the target node is checked to ensure it is > * currently a legitimate target of an RMA operation. > * - If the target node is the origin node, and the epoch type > * is \e LOCK, then require that the local lock be acquired. > * - If the operand is MPI_REPLACE, then perform a Put instead. > * - Require that the oprand be a built-in operand. > * - If the origin datatype is non-contiguous, allocate a buffer > * and pack the origin data into a contiguous buffer. > * - If the target datatype is not built-in, send the target > * datatype to the target node for caching there (sending of > * a particular datatype to a particular target is done only > * once per job). > * - Send a message of type MPID_MSGTYPE_DT_MAP which contains > * the datatype map structure as created by make_dt_map_vec(). > * - Send a message of type MPID_MSGTYPE_DT_IOV which contains > * the datatype iov structure, also created by make_dt_map_vec(). > * - Create the msg info for the accumulate operation. > * - Call DCMF_Send to send the data and associated parameters > * to the target node. > * - Increment the RMA operations count for target node. > * - Wait for all sends to complete, calling advance in the loop. > * > * Target node invokes the receive callback > * > * If the datatype was sent, cases \e MPID_MSGTYPE_DT_MAP and > * \e MPID_MSGTYPE_DT_IOV will be invoked, in sequence. > * > * Case: MPID_MSGTYPE_DT_MAP > * > * - Sanity-check the message by testing for msginfo count of 1. > * - Allocate space for the map and store its pointer in the datatype > * cache element. > * - Receive the remote map contents. > * > * Case: MPID_MSGTYPE_DT_IOV > * > * - Sanity-check the message by testing for msginfo count of 1. > * - Allocate a iov buffer and store its pointer in the datatype > * cache element's dataloop field. > * - Receive the remote datatype iov contents. > * > * Case: MPID_MSGTYPE_ACC > * > * - Sanity-check message... > * - Setup operand function pointer. > * - Invoke operand from \e MPIR_Op_table on received data and > * specified target window buffer. > * - Increment counter of received RMA operations. > */ > /// \cond NOT_REAL_CODE > #undef FUNCNAME > #define FUNCNAME MPID_Accumulate > #undef FCNAME > #define FCNAME MPIU_QUOTE(FUNCNAME) > /// \endcond > /** > * \brief MPI-DCMF glue for MPI_ACCUMULATE function > * > * Perform DEST = DEST (op) SOURCE for \e origin_count number of > * \e origin_datatype at \e origin_addr > * to node \e target_rank into \e target_count number of \e target_datatype > * into window location \e target_disp offset (window displacement units) > * > * According to the MPI Specification: > * > * Each datatype argument must be a predefined datatype or > * a derived datatype, where all basic components are of the > * same predefined datatype. Both datatype arguments must be > * constructed from the same predefined datatype. > * > * \param[in] origin_addr Source buffer > * \param[in] origin_count Number of datatype elements > * \param[in] origin_datatype Source datatype > * \param[in] target_rank Destination rank (target) > * \param[in] target_disp Displacement factor in target buffer > * \param[in] target_count Number of target datatype elements > * \param[in] target_datatype Destination datatype > * \param[in] op Operand to perform > * \param[in] win_ptr Window > * \return MPI_SUCCESS, MPI_ERR_RMA_SYNC, MPI_ERR_OP, > * or error returned from MPIR_Localcopy, MPID_Segment_init, > * mpid_queue_datatype, or DCMF_Send. > * > * \ref msginfo_usage\n > * \ref accum_design > */ > int MPID_Accumulate(void *origin_addr, int origin_count, > MPI_Datatype origin_datatype, int target_rank, > MPI_Aint target_disp, int target_count, > MPI_Datatype target_datatype, MPI_Op op, MPID_Win *win_ptr) > { > int mpi_errno = MPI_SUCCESS; > int dt_contig, rank; > MPID_Datatype *dtp; > MPI_Aint dt_true_lb; > MPIDI_msg_sz_t data_sz; > int lpid; > mpid_dt_info dti = {0}; > int i, j; > char *buf; > int sent = 0; > DCQuad xtra = {0}; > int *refp = NULL; > DCMF_Callback_t cb_send; > char *s, *dd; > DCMF_Request_t *reqp; > MPIDU_Onesided_info_t *info; > DCMF_Consistency consistency = win_ptr->_dev.my_cstcy; > MPIU_THREADPRIV_DECL; > MPID_MPI_STATE_DECL(MPID_STATE_MPID_WIN_ACCUMULATE); > > MPID_MPI_FUNC_ENTER(MPID_STATE_MPID_WIN_ACCUMULATE); > MPIU_THREADPRIV_GET; > MPIR_Nest_incr(); > > if (win_ptr->_dev.epoch_type == MPID_EPOTYPE_NONE || > win_ptr->_dev.epoch_type == MPID_EPOTYPE_POST || > !MPIDU_VALID_RMA_TARGET(win_ptr, target_rank)) { > /* --BEGIN ERROR HANDLING-- */ > MPIU_ERR_SETANDSTMT(mpi_errno, MPI_ERR_RMA_SYNC, > goto fn_fail, "**rmasync"); > /* --END ERROR HANDLING-- */ > } > if (op == MPI_REPLACE) { > /* Just do a PUT instead... */ > mpi_errno = MPID_Put(origin_addr, origin_count, origin_datatype, > target_rank, target_disp, target_count, target_datatype, win_ptr); > if (mpi_errno) { MPIU_ERR_POP(mpi_errno); } > goto fn_exit; > } > > MPIDI_Datatype_get_info(origin_count, origin_datatype, > dt_contig, data_sz, dtp, dt_true_lb); > if ((data_sz == 0) || (target_rank == MPI_PROC_NULL)) { > goto fn_exit; > } > if (DATATYPE_ADDITIONAL(origin_datatype)) { > dt_contig = 1; // treat MINLOC/MAXLOC types as contig > data_sz = origin_count * dtp->extent; > } > rank = win_ptr->_dev.comm_ptr->rank; > lpid = MPIDU_world_rank(win_ptr, target_rank); > > if (!DATATYPE_PREDEFINED(target_datatype)) { > /* force map to get built but don't assume it was sent (use our lpid) */ > (void)MPIDU_check_dt(mpid_my_lpid, target_datatype, &dti); > MPID_assert(dti.map != NULL); > MPID_assert(dti.map[0].dt != 0); > } > if (target_rank == rank) { > /* > * We still must have acquired the lock, unless > * we specified NOCHECK. > */ > if (win_ptr->_dev.epoch_type == MPID_EPOTYPE_LOCK && > !(win_ptr->_dev.epoch_assert & MPI_MODE_NOCHECK) && > MPIDU_is_lock_free(win_ptr)) { > /* --BEGIN ERROR HANDLING-- */ > MPIU_ERR_SETANDSTMT(mpi_errno, MPI_ERR_RMA_SYNC, > goto fn_fail, "**rmasync"); > /* --END ERROR HANDLING-- */ > } > } else { > MPIU_ERR_CHKANDJUMP1( > (HANDLE_GET_KIND(op) != HANDLE_KIND_BUILTIN), > mpi_errno, MPI_ERR_OP, "**opnotpredefined", > "**opnotpredefined %d", op ); > } > > if (dt_contig) { /* all builtin datatypes are also contig */ > buf = origin_addr; > cb_send.function = done_rqc_cb; > } else { > MPID_Segment segment; > DLOOP_Offset last = data_sz; > > MPIDU_MALLOC(buf, char, data_sz + sizeof(int), mpi_errno, "MPID_Accumulate"); > if (buf == NULL) { > MPID_Abort(NULL, MPI_ERR_NO_SPACE, -1, > "Unable to allocate non-" > "contiguous buffer"); > } > refp = (int *)buf; > xtra.w1 = (unsigned)refp; > xtra.w2 = (unsigned)buf; > cb_send.function = done_reffree_rqc_cb; > buf += sizeof(int); > *refp = 0; > mpi_errno = MPID_Segment_init(origin_addr, origin_count, > origin_datatype, &segment, 0); > if (mpi_errno) { MPIU_ERR_POP(mpi_errno); } > MPID_Segment_pack(&segment, 0, &last, buf); > MPID_assert_debug(last == data_sz); > } > dd = win_ptr->_dev.coll_info[target_rank].base_addr + > win_ptr->_dev.coll_info[target_rank].disp_unit * target_disp; > if (DATATYPE_PREDEFINED(target_datatype)) { > if (target_rank == rank) { /* local accumulate */ > local_accumulate(win_ptr, dd, buf, lpid, > target_datatype, op, target_count); > } else { /* ! local accumulate */ > if (DATATYPE_ADDITIONAL(target_datatype)) { > > MPID_Datatype_get_ptr(target_datatype, dtp); > data_sz = dtp->extent; > } else { > data_sz = MPID_Datatype_get_basic_size(target_datatype); > } > xtra.w0 = (unsigned)&win_ptr->_dev.my_rma_pends; > reqp = MPIDU_get_req(&xtra, &info); > info->mpid_info_w0 = MPID_MSGTYPE_ACC; > info->mpid_info_w1 = win_ptr->_dev.coll_info[target_rank].win_handle; > info->mpid_info_w2 = rank; > info->mpid_info_w3 = (unsigned)dd; > info->mpid_info_w4 = target_datatype; > info->mpid_info_w5 = op; > info->mpid_info_w6 = target_count; > info->mpid_info_w7 = 0; > ++win_ptr->_dev.my_rma_pends; > if (refp) { ++*refp; } > ++sent; > cb_send.clientdata = reqp; > mpi_errno = DCMF_Send(&bg1s_sn_proto, reqp, cb_send, > consistency, lpid, > target_count * data_sz, > buf, info->info, 2); > if (mpi_errno) { MPIU_ERR_POP(mpi_errno); } > ++win_ptr->_dev.coll_info[target_rank].rma_sends; > } /* ! local accumulate */ > } else { > s = buf; > if (refp) *refp = target_count * dti.map_len; > for (j = 0; j < target_count; ++j) { > for (i = 0; i < dti.map_len; ++i) { > if (target_rank == rank) { /* local accumulate */ > local_accumulate(win_ptr, dd + dti.map[i].off, > s, lpid, > dti.map[i].dt, op, dti.map[i].num); > } else { /* ! local accumulate */ > > MPIDU_Progress_spin(win_ptr->_dev.my_rma_pends > > MPIDI_Process.rma_pending); > xtra.w0 = (unsigned)&win_ptr->_dev.my_rma_pends; > reqp = MPIDU_get_req(&xtra, &info); > info->mpid_info_w0 = MPID_MSGTYPE_ACC; > info->mpid_info_w1 = win_ptr->_dev.coll_info[target_rank].win_handle; > info->mpid_info_w2 = rank; > info->mpid_info_w3 = (unsigned)dd + dti.map[i].off; > info->mpid_info_w4 = dti.map[i].dt; > info->mpid_info_w5 = op; > info->mpid_info_w6 = dti.map[i].num; > info->mpid_info_w7 = 0; > ++win_ptr->_dev.my_rma_pends; > ++sent; > cb_send.clientdata = reqp; > mpi_errno = DCMF_Send(&bg1s_sn_proto, reqp, cb_send, > consistency, lpid, dti.map[i].len, s, info->info, 2); > if (mpi_errno) { MPIU_ERR_POP(mpi_errno); } > ++win_ptr->_dev.coll_info[target_rank].rma_sends; > } /* ! local accumulate */ > s += dti.map[i].len; > } /* for map_len */ > dd += dti.dtp->extent; > } /* for target_count */ > } > /* > * TBD: Could return without waiting for sends... > */ > MPIDU_Progress_spin(win_ptr->_dev.my_rma_pends > 0); > if (sent == 0 && xtra.w2) { > MPIDU_FREE(xtra.w2, mpi_errno, "MPID_Accumulate"); > } > > fn_exit: > MPIR_Nest_decr(); > MPID_MPI_FUNC_EXIT(MPID_STATE_MPID_WIN_ACCUMULATE); > return mpi_errno; > /* --BEGIN ERROR HANDLING-- */ > fn_fail: > goto fn_exit; > /* --END ERROR HANDLING-- */ > } diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/onesided/mpid_get.c bgp-mpich2/src/mpid/dcmf/src/onesided/mpid_get.c 0a1,216 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file src/onesided/mpid_get.c > * \brief MPI-DCMF MPI_Get functionality > */ > > #include "mpid_onesided.h" > > /** > * \page get_design MPID_Get Design > * > * A MPID_Get sequence is as follows: > * > * Origin node calls MPI_Get > * > * - A sanity-check is done to > * ensure that the window is in a valid state to initiate > * a get RMA operation. > * These checks include testing that > * the epoch currently in affect is not \e NONE or \e POST. > * - If target rank is origin rank, call MPIR_Localcopy. > * - If origin datatype is not contiguous, allocate a buffer > * for contiguous data. > * - If target datatype is contiguous, get data from target node > * into local buffer. > * - If target datatype is non-contiguous: > * - Create IO Vector from target datatype. > * - Perform multiple get's from target into local buffer. > * - If origin datatype is not contiguous, unpack data from buffer > * into local window. (free buffer) > */ > /// \cond NOT_REAL_CODE > #undef FUNCNAME > #define FUNCNAME MPID_Get > #undef FCNAME > #define FCNAME MPIU_QUOTE(FUNCNAME) > /// \endcond > /** > * \brief MPI-DCMF glue for MPI_GET function > * > * Get \e target_count number of \e target_datatype from \e target_rank > * from window location \e target_disp offset (window displacement units) > * into \e origin_count number of \e origin_datatype at \e origin_addr > * > * \param[in] origin_addr Source buffer > * \param[in] origin_count Number of datatype elements > * \param[in] origin_datatype Source datatype > * \param[in] target_rank Destination rank (target) > * \param[in] target_disp Displacement factor in target buffer > * \param[in] target_count Number of target datatype elements > * \param[in] target_datatype Destination datatype > * \param[in] win_ptr Window > * \return MPI_SUCCESS, MPI_ERR_RMA_SYNC, or error returned from > * MPIR_Localcopy, MPID_Segment_init, or DCMF_Get. > * > * \ref msginfo_usage\n > * \ref get_design > */ > int MPID_Get(void *origin_addr, int origin_count, > MPI_Datatype origin_datatype, int target_rank, > MPI_Aint target_disp, int target_count, > MPI_Datatype target_datatype, MPID_Win *win_ptr) > { > int mpi_errno = MPI_SUCCESS; > int dt_contig, rank; > MPID_Datatype *dtp; > MPI_Aint dt_true_lb; > MPIDI_msg_sz_t data_sz; > MPIU_THREADPRIV_DECL; > MPID_MPI_STATE_DECL(MPID_STATE_MPID_GET); > > MPID_MPI_FUNC_ENTER(MPID_STATE_MPID_GET); > MPIU_THREADPRIV_GET; > MPIR_Nest_incr(); > > if (win_ptr->_dev.epoch_type == MPID_EPOTYPE_NONE || > win_ptr->_dev.epoch_type == MPID_EPOTYPE_POST || > !MPIDU_VALID_RMA_TARGET(win_ptr, target_rank)) { > /* --BEGIN ERROR HANDLING-- */ > MPIU_ERR_SETANDSTMT(mpi_errno, MPI_ERR_RMA_SYNC, > goto fn_fail, "**rmasync"); > /* --END ERROR HANDLING-- */ > } > > MPIDI_Datatype_get_info(origin_count, origin_datatype, > dt_contig, data_sz, dtp, dt_true_lb); > if ((data_sz == 0) || (target_rank == MPI_PROC_NULL)) { > goto fn_exit; > } > rank = win_ptr->_dev.comm_ptr->rank; > > /* If the get is a local operation, do it here */ > if (target_rank == rank) { > mpi_errno = MPIR_Localcopy( > (char *)win_ptr->base + > win_ptr->disp_unit * target_disp, > target_count, target_datatype, > origin_addr, origin_count, origin_datatype); > if (mpi_errno) { MPIU_ERR_POP(mpi_errno); } > } else { > /* queue it up */ > /* > * Since GET can never be left pending, we keep > * GETs separate from other RMA ops which might not > * complete until later. We also do not increment > * [target]rma_sends here. > */ > DCMF_Callback_t cb_send; > DCMF_Request_t *reqp; > int t_dt_contig; > MPID_Datatype *t_dtp; > MPI_Aint t_dt_true_lb; > MPIDI_msg_sz_t t_data_sz; > mpid_dt_info dti; > int i, j, get_len; > int *refp = NULL; > char *b, *s, *t, *buf; > int lpid; > DCQuad xtra = {0}; > > lpid = MPIDU_world_rank(win_ptr, target_rank); > MPIDI_Datatype_get_info(target_count, target_datatype, > t_dt_contig, t_data_sz, t_dtp, t_dt_true_lb); > /* NOTE! t_data_sz already is adjusted for target_count */ > > get_len = (data_sz < t_data_sz ? data_sz : t_data_sz); > > xtra.w0 = (unsigned)&win_ptr->_dev.my_get_pends; > if (dt_contig) { > buf = origin_addr; > cb_send.function = done_rqc_cb; > } else { > struct mpid_get_cb_data *get; > MPIDU_MALLOC(buf, char, get_len + sizeof(struct mpid_get_cb_data), mpi_errno, "MPID_Get"); > if (buf == NULL) { > MPID_Abort(NULL, MPI_ERR_NO_SPACE, -1, > "Unable to allocate non-" > "contiguous buffer"); > } > MPID_Datatype_add_ref(dtp); > get = (struct mpid_get_cb_data *)buf; > buf += sizeof(struct mpid_get_cb_data); > get->ref = 0; > refp = &get->ref; > get->dtp = dtp; > get->addr = origin_addr; > get->count = origin_count; > get->len = get_len; > get->buf = buf; > xtra.w1 = (unsigned)get; > xtra.w2 = (unsigned)get; > cb_send.function = done_getfree_rqc_cb; > } > if (t_dt_contig) { > t = win_ptr->_dev.coll_info[target_rank].base_addr + > win_ptr->_dev.coll_info[target_rank].disp_unit * target_disp; > reqp = MPIDU_get_req(&xtra, NULL); > cb_send.clientdata = reqp; > ++win_ptr->_dev.my_get_pends; > if (refp) ++(*refp); > mpi_errno = DCMF_Get(&bg1s_gt_proto, reqp, > cb_send, win_ptr->_dev.my_cstcy, lpid, > t_data_sz, > buf, t); > if (mpi_errno) { MPIU_ERR_POP(mpi_errno); } > } else { > /* force map to get built but don't assume > * it was sent (use our lpid) */ > (void)MPIDU_check_dt(mpid_my_lpid, target_datatype, &dti); > MPID_assert(dti.map != NULL); > b = win_ptr->_dev.coll_info[target_rank].base_addr + > win_ptr->_dev.coll_info[target_rank].disp_unit * > target_disp; > s = buf; > if (refp) *refp = target_count * dti.map_len; > for (j = 0; j < target_count; ++j) { > for (i = 0; i < dti.map_len; i++) { > MPIDU_Progress_spin(win_ptr->_dev.my_get_pends > > MPIDI_Process.rma_pending); > t = b + dti.map[i].off; > reqp = MPIDU_get_req(&xtra, NULL); > cb_send.clientdata = reqp; > ++win_ptr->_dev.my_get_pends; > mpi_errno = DCMF_Get(&bg1s_gt_proto, > reqp, cb_send, > win_ptr->_dev.my_cstcy, lpid, > dti.map[i].len, s, t); > if (mpi_errno) { MPIU_ERR_POP(mpi_errno); } > s += dti.map[i].len; > } > b += dti.dtp->extent; > } > } > /** > * \todo we don't know when the "request to get" messages have been sent, > * but we should wait for that. > */ > } > > fn_exit: > MPIR_Nest_decr(); > MPID_MPI_FUNC_EXIT(MPID_STATE_MPID_GET); > return mpi_errno; > > /* --BEGIN ERROR HANDLING-- */ > fn_fail: > goto fn_exit; > /* --END ERROR HANDLING-- */ > } diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/onesided/mpid_misc.c bgp-mpich2/src/mpid/dcmf/src/onesided/mpid_misc.c 0a1,110 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file src/onesided/mpid_misc.c > * \brief MPI-DCMF Left-over stuff not part of RMA > */ > > #include "mpidimpl.h" > > /// \cond NOT_DOCUMENTED > /** > * \brief Obsolete hack for intercomm support > * > * In MPICH 1.0.3, this call was added as a temporary hack for > * intercomm support. > * > * In the bgl device, we don't use gpids > * so this is a "do nothing function" > */ > int MPID_PG_ForwardPGInfo( MPID_Comm *peer_ptr, MPID_Comm *comm_ptr, > int nPGids, int gpids[], int root) { > > return 0; > } > > /* ---- these are new in MPICH2 0.94b1 ------- */ > > #undef FUNCNAME > #define FUNCNAME MPID_Open_port > #undef FCNAME > #define FCNAME MPIU_QUOTE(FUNCNAME) > /** > * \brief MPI-DCMF glue for MPI_OPEN_PORT function > */ > int MPID_Open_port(MPID_Info *info_ptr, char *port_name) > { > MPID_abort(); > } > > #undef FUNCNAME > #define FUNCNAME MPID_Close_port > #undef FCNAME > #define FCNAME MPIU_QUOTE(FUNCNAME) > /** > * \brief MPI-DCMF glue for MPI_CLOSE_PORT function > */ > int MPID_Close_port(const char *port_name) > { > MPID_abort(); > } > > #undef FUNCNAME > #define FUNCNAME MPID_Comm_connect > #undef FCNAME > #define FCNAME MPIU_QUOTE(FUNCNAME) > /** > * \brief MPI-DCMF glue for MPI_COMM_CONNECT function > */ > int MPID_Comm_connect(const char *port_name, MPID_Info *info_ptr, > int root, MPID_Comm *comm_ptr, MPID_Comm **newcomm) > { > MPID_abort(); > } > > #undef FUNCNAME > #define FUNCNAME MPID_Comm_spawn_multiple > #undef FCNAME > #define FCNAME MPIU_QUOTE(FUNCNAME) > /** > * \brief MPI-DCMF glue for MPI_COMM_SPAWN_MULTIPLE function > */ > int MPID_Comm_spawn_multiple(int count, char *array_of_commands[], > char* *array_of_argv[], int array_of_maxprocs[], > MPID_Info *array_of_info[], int root, MPID_Comm *comm_ptr, > MPID_Comm **intercomm, int array_of_errcodes[]) > { > MPID_abort(); > } > > #undef FUNCNAME > #define FUNCNAME MPID_Comm_accept > #undef FCNAME > #define FCNAME MPIU_QUOTE(FUNCNAME) > /** > * \brief MPI-DCMF glue for MPI_COMM_ACCEPT function > */ > int MPID_Comm_accept(char *port_name, MPID_Info *info_ptr, int root, > MPID_Comm *comm_ptr, MPID_Comm **newcomm) > { > MPID_abort(); > } > > #undef FUNCNAME > #define FUNCNAME MPID_Comm_disconnect > #undef FCNAME > #define FCNAME MPIU_QUOTE(FUNCNAME) > /** > * \brief MPI-DCMF glue for MPI_COMM_DISCONNECT function > */ > int MPID_Comm_disconnect(MPID_Comm *comm_ptr) > { > MPID_abort(); > } > /// \endcond diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/onesided/mpid_onesided.h bgp-mpich2/src/mpid/dcmf/src/onesided/mpid_onesided.h 0a1,1361 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file src/onesided/mpid_onesided.h > * \brief MPI-DCMF Common declarations and definitions for RMA > */ > > #include "mpidimpl.h" > > /* redefine these for debugging purposes */ > /** > * \brief Macro for allocating memory > * > * \param[out] p variable to receive new pointer > * \param[in] t type of "p", excluding "*" > * \param[in] z size in bytes to allocate > * \param[in] e variable to receive error code > * \param[in] n string to identify where/what allocation is > * \return nothing, per ce. fills in "p" with address or NULL > */ > #define MPIDU_MALLOC(p, t, z, e, n) p = (t *)MPIU_Malloc(z) > > /** > * \brief Macro for allocating memory > * > * \param[in] p variable containing address to be freed > * \param[in] e variable to receive error code > * \param[in] n string to identify where/what allocation/free is > */ > #define MPIDU_FREE(p, e, n) MPIU_Free((void *)p) > > /** > * \brief structure of DCMF_Control_t as used by RMA ops > * > * DCMF_Control_t is assumed to be one quad. > */ > typedef union { > DCMF_Control_t ctl; /**< access to underlying type */ > struct { > unsigned _0w0; /**< word 0 */ > unsigned _0w1; /**< word 1 */ > unsigned _0w2; /**< word 2 */ > unsigned _0w3; /**< word 3 */ > } _c_u; /**< overlay of DCMF_Control_t */ > } MPIDU_Onesided_ctl_t __attribute__ ((__aligned__ (16))); > > #define mpid_ctl_w0 _c_u._0w0 /**< ctl word 0 */ > #define mpid_ctl_w1 _c_u._0w1 /**< ctl word 1 */ > #define mpid_ctl_w2 _c_u._0w2 /**< ctl word 2 */ > #define mpid_ctl_w3 _c_u._0w3 /**< ctl word 3 */ > > /** > * \brief structure of "msginfo" as used by RMA ops > * > * We always use 2 quads, just for consistency. > */ > typedef union { > DCQuad info[2]; /**< access to underlying type */ > struct { > unsigned _0w0; /**< word 0 */ > unsigned _0w1; /**< word 1 */ > unsigned _0w2; /**< word 2 */ > unsigned _0w3; /**< word 3 */ > unsigned _1w0; /**< word 4 */ > unsigned _1w1; /**< word 5 */ > unsigned _1w2; /**< word 6 */ > unsigned _1w3; /**< word 7 */ > } _i_u; /**< overlay of DCQuads */ > } MPIDU_Onesided_info_t __attribute__ ((__aligned__ (16))); > > #define mpid_info_w0 _i_u._0w0 /**< info word 0 */ > #define mpid_info_w1 _i_u._0w1 /**< info word 1 */ > #define mpid_info_w2 _i_u._0w2 /**< info word 2 */ > #define mpid_info_w3 _i_u._0w3 /**< info word 3 */ > #define mpid_info_w4 _i_u._1w0 /**< info word 4 */ > #define mpid_info_w5 _i_u._1w1 /**< info word 5 */ > #define mpid_info_w6 _i_u._1w2 /**< info word 6 */ > #define mpid_info_w7 _i_u._1w3 /**< info word 7 */ > > #if 0 > /** > * \brief Translate message type into string > */ > extern char *msgtypes[]; > #endif > > /** \brief DCMF Protocol object for DCMF_Send() calls */ > extern DCMF_Protocol_t bg1s_sn_proto; > /** \brief DCMF Protocol object for DCMF_Get() calls */ > extern DCMF_Protocol_t bg1s_gt_proto; > /** \brief DCMF Protocol object for DCMF_Control() calls */ > extern DCMF_Protocol_t bg1s_ct_proto; > > /** \brief global for our lpid */ > extern unsigned mpid_my_lpid; > > /** > * \brief struct used by MPID_Get to delay unpacking of datatype > * > * Active only when the origin datatype is non-contiguous. > * Reference count is used to determine when the last chunk of > * data is received, rest of struct is used to unpack data. > */ > struct mpid_get_cb_data { > int ref; /**< reference counter */ > MPID_Datatype *dtp; /**< datatype object */ > void *addr; /**< origin address of get */ > int count; /**< origin count */ > int len; /**< computed length of get */ > char *buf; /**< temp buffer of packed data */ > }; > > /** \brief datatype map entry - adjacent fields with same datatype are combined > * > * map[x].len = map[x].num * MPID_Datatype_get_basic_size(map[x].dt); > * map[x+1].off = map[x].off + map[x].len + ; > * > */ > typedef struct MPID_Type_map { > unsigned off; /**< offset in datatype */ > unsigned len; /**< length of map segment */ > unsigned num; /**< number of fields */ > MPI_Datatype dt; /**< datatype of fields */ > } MPID_Type_map; > > /*******************************************************/ > > /** > * \brief Structure to house info on cached datatypes > * > * Used to store info in the actual cache, and also to pass > * info back and forth. > * > * Only derived datatypes ever use this. eltype and elsize are > * zero if the dtp->eltype is not builtin. MPID_Accumulate() > * uses this for error checking. > */ > typedef struct { > MPID_Datatype *dtp; /**< datatype object */ > int _pad; /**< padding to power of 2 length */ > MPID_Type_map *map; /**< datatype map */ > int map_len; /**< datatype map length */ > } mpid_dt_info; > > /** > * \brief Build datatype map and iovec > * > * \param[in] dt Datatype to build map/iov for > * \param[out] dti Pointer to datatype info struct > */ > void make_dt_map_vec(MPI_Datatype dt, mpid_dt_info *dti); > > > /** \brief Hi-order bit of integer type \note should be taken from standard include */ > #define INT_MSB (1UL << (sizeof(int) * 8 - 1)) > > /** > * \brief Datatype created to represent the rma_sends element > * of the coll_info array of the window structure > */ > extern MPI_Datatype Coll_info_rma_dt; > /** > * \brief User defined function created to process the rma_sends > * elements of the coll_info array of the window structure > */ > extern MPI_Op Coll_info_rma_op; > > /** > * \brief Dummy, global, MPID_Progress_state since its not used. > */ > extern MPID_Progress_state dummy_state; > /** > * \brief Progress (advance) wait - how to spin and make progress > * > * 'expr' is true if must wait, i.e. > * while(expr) { make_progress; } > * > * Guaranteed to call DCMF_Messager_advance() _at least_ once > * (via MPID_Progress_wait()) > * > * In DCMF, MPID_Progress_wait() never returns an error... > * Also, MPID_Progress_state is never used. > * > * \param[in] expr Conditional expression to be evaluated on each loop, > * FALSE will terminate loop. > * \return nothing > */ > #define MPIDU_Progress_spin(expr) { \ > MPID_Progress_start(&dummy_state);\ > do { \ > (void)MPID_Progress_test();\ > MPID_CS_EXIT(); \ > MPID_CS_ENTER(); \ > } while (expr); \ > MPID_Progress_end(&dummy_state);\ > } > > /* > * * * * * Generic resource pool management * * * * * > */ > > /** > * \page rsrc_design Basic resource element design > * > * Generic resources are managed through a \e mpid_qhead structure > * which defines the basic geometry of the allocation blocks and > * references the first allocated block. > * > * Generic resources are allocated in blocks. Each block begins > * with a header of \e mpid_resource and is followed by a number > * of elements whose size and count are defined for each resource > * type. Also, the header size is defined, which may be larger > * than the natural size of \e mpid_resource in order to optimize > * memory layout (i.e. cache usage). > * > * Resource blocks are never freed (exception: lock wait queue > * resources are freed when the window is freed). > * > * Specific resources are defined by their elements. Every resource > * element must have as its first field the \e next pointer, as > * defined by \e mpid_element. Following this is > * defined by the needs of the specific resource. > * > * A newly allocated block is initialized with all elements \e next > * chained together and the block's \e next_free pointer set to the > * first (free) element. Except for the first allocated block > * (the one directly referenced by \e mpid_qhead), the \e next_free > * is not used again. This also applies to the \e next_used and > * \e last_used pointers. > * > * A newly allocated secondary block is linked into the \e mpid_qhead > * \e next_block chain and \e next_free chain. > * > * When an element is taken from the free list, it is always taken > * from the top of the list, i.e. directly from \e next_free. > * When an element is returned to the free list, it is placed > * (pushed) on the top. So an element to be allocated is always the > * one most-recently freed, i.e. a LIFO queue. > * > * When an element is added to the used list, it is always added > * to the end of the list, i.e. using the \e last_used pointer. > * If an arbitrary element is taken from the used list, it is > * taken from the top of the list, i.e. using \e next_used. This > * effectively forms a FIFO queue. > * > * Other routines exist that permit the used list to be searched, > * and the found element may be removed from the used list > * "out of turn". A specific resource implementation decides > * how it will use this list. > */ > > /** > * \brief Basic resource element structure. > * > * This implements the basic linked-list pointer(s) > * needed to manage generic elements. > * An actual element implementation will have additional > * fields. > * > * \ref rsrc_design > */ > struct mpid_element { > struct mpid_element *next; /**< next used or next free */ > }; > > /** > * \brief Resource block header structure. > * > * This structure exists at the beginning of each > * allocated block of elements. > * > * \ref rsrc_design > */ > struct mpid_resource { > struct mpid_element *next_used; /**< Pointer to top of queue */ > struct mpid_element *last_used; /**< Pointer to bottom of queue */ > struct mpid_element *next_free; /**< Pointer to top of free list */ > struct mpid_resource *next_block; /**< Pointer to next allocated block */ > }; > > /** > * \brief Resource "queue head" structure. > * > * This structure is required to exist and be initialized > * before any resource or element management functions are call. > * > * \ref rsrc_design > */ > struct mpid_qhead { > int num; /**< number of elements per block */ > short len; /**< length of each element */ > short hdl; /**< length of header in block */ > struct mpid_resource *blocks; /**< Allocated block(s) chain */ > struct mpid_resource *lastblock; /**< last block in chain */ > }; > > /** > * \brief Queue-head static initializer. > * > * This is used to initialize a mpid_qhead structure at > * compile-time. > * > * \param[in] n number of elements per block > * \param[in] l length (bytes) of each element > * \param[in] p padding for header: added to sizeof(mpid_resource) > * \return static initializer > * > * \ref rsrc_design > */ > #define MPIDU_INIT_QHEAD_DECL(n, l, p) \ > { (n), (l), sizeof(struct mpid_resource) + p, NULL } > > /** > * \brief Queue-head dynamic initializer. > * > * This is used to initialize a mpid_qhead structure at > * runtime. > * > * \param[in] qp pointer to mpid_qhead structure > * \param[in] n number of elements per block > * \param[in] l length (bytes) of each element > * \param[in] p padding for header: added to sizeof(mpid_resource) > * \return n/a > * > * \ref rsrc_design > */ > #define MPIDU_INIT_QHEAD(qp, n, l, p) { \ > (qp)->num = n; \ > (qp)->len = l; \ > (qp)->hdl = sizeof(struct mpid_resource) + p; \ > (qp)->blocks = NULL; \ > } > > /** > * \brief Allocate a new block of elements. > * > * Unconditionally allocates a block of resources as described by > * 'qhead' and link the block into 'qhead'. The new elements > * are added to the 'qhead' free list. The new elements are > * uninitialized except for the mpid_element field(s). > * > * \param[in] qhead Queue Head > * \return nothing > * > * \ref rsrc_design > */ > void MPIDU_alloc_resource(struct mpid_qhead *qhead); > > /** > * \brief Unconditionally free all resource blocks > * referenced by 'qhead'. > * > * NOTE: elements such as datatype cache require addition freeing > * and so won't work with this. We could add a "free func ptr" to > * qhead and call it here - so each element type can free any other > * buffers it may have allocated. > * > * Right now, this is only called by Win_free() on the lock and unlock > * wait queues, which do no additional allocation. > * > * \param[in] qhead Queue Head > * \return nothing > * > * \ref rsrc_design > */ > void MPIDU_free_resource(struct mpid_qhead *qhead); > > /** > * \brief Get a new (unused) resource element. > * > * Take a resource element off the free list and put it on the > * end of used list (bottom of queue). Element is uninitialized > * except for mpid_element structure fields. > * > * \param[in] qhead Queue Head > * \return pointer to element. > * > * \ref rsrc_design > */ > void *MPIDU_get_element(struct mpid_qhead *qhead); > > /** > * \brief Initialize a new (unused) element. > * > * Get a new element from free list and initialize its contents > * from 'el'. Element is placed at bottom of queue. > * 'el' is assumed to be of qhead->len size. > * > * \param[in] qhead Queue Head > * \param[in] el Pointer to new element data > * \return pointer to element. > * > * \ref rsrc_design > */ > void *MPIDU_add_element(struct mpid_qhead *qhead, void *el); > > /** > * \brief Peek at top element in queue (used list). > * > * Copy contents of first element in used list (top of queue) > * into 'el'. Does not alter qhead (used or free lists). > * 'el' is assumed to be of qhead->len size. > * > * \param[in] qhead Queue Head > * \param[out] el Pointer to destination for element data > * \return 1 if no elements on queue or > * 0 on success with 'el' filled-in. > * > * \ref rsrc_design > */ > int MPIDU_peek_element(struct mpid_qhead *qhead, void *el); > > /** > * \brief Free an element. > * > * Remove element 'el' (parent element 'pe') from used list > * and place on free list. Typically, this is only called > * after calling MPIDU_find_element() to obtain 'el' and 'pe'. > * > * (See MPIDU_free_resource()) This does not take into account > * any additional allocations done by the element type. Whether > * any such buffers need to be freed depends on how the element- > * type re-uses elements (when taken off the free list). > * > * \param[in] qhead Queue Head > * \param[in] el Element object > * \param[in] pe Parent element object, or NULL if 'el' > * is at top of queue. > * \return nothing > * > * \ref rsrc_design > */ > void MPIDU_free_element(struct mpid_qhead *qhead, void *el, void *pe); > > /** > * \brief Pop first element off used list (top of queue). > * > * Element contents is copied into 'el', if not NULL. > * Popped element is placed on free list. > * Returns 0 (success) if element was popped, or 1 if list empty. > * > * \param[in] qhead Queue Head > * \param[out] el Element contents buffer > * \return 1 if no elements on queue or > * 0 on success with 'el' filled-in. > * > * \ref rsrc_design > */ > int MPIDU_pop_element(struct mpid_qhead *qhead, void *el); > > /** > * \brief Find specific element in queue. > * > * Find element in used list that "matches" according to > * 'func'('el', ...). 'func' is called with arbitrary parameter 'el' > * and pointer to element under test. Only one element is found, > * always the first "match". 'func' returns 0 for match (success). > * > * Returns NULL if no match found. > * If 'parent' is not NULL, returns pointer to parent element there. > * Note, '*parent' == NULL means element is first in list. > * > * \param[in] qhead Queue Head > * \param[in] func Function to use to test for desired element > * \param[in] v3 void arg passed to \e func in 3rd arg > * \param[in] el Static first parameter for 'func' > * \param[in,out] parent Pointer to parent element to start search from; > * Pointer to parent element of match found, > * or NULL if 'el' is at top of queue. > * \return Pointer to element found with 'parent' set, > * or NULL if not found. > * > * \ref rsrc_design > */ > void *MPIDU_find_element(struct mpid_qhead *qhead, > int (*func)(void *, void *, void *), void *v3, void *el, > struct mpid_element **parent); > > /* > * * * * * Win Locks and Lock wait queue * * * * * > */ > > /** > * \brief Progress (advance) wait for window lock to be released > * > * Adds a dummy waiter to the lock wait queue, so ensure that > * unlock will eventually give us a chance. > * > * Called from various epoch-start code to ensure no other node is > * accessing our window while we are in another epoch. > * > * \todo Probably sohuld assert that the popped waiter, > * if any, was our NULL one. > * > * \param[in] win Pointer to MPID_Win object > * \return nothing > */ > void MPIDU_Spin_lock_free(MPID_Win *win); > > /** > * \brief Test whether window lock is free > * > * \param[in] win Pointer to MPID_Win object > * \return Boolean TRUE if lock is free > */ > int MPIDU_is_lock_free(MPID_Win *win); > > /* > * * * * * Unlock wait queue * * * * * > */ > > /* > * * * * * Remote (origin, foreign) Datatype cache * * * * * > */ > > /** > * \page dtcache_design Datatype Cache Design > * > * The datatype cache element stores the rank, datatype handle > * and the localized datatype object (map and iovec). Builtin > * datatypes are not cached (and not sent). > * > * This cache is used in a split fashion, where "cloned" > * cache entries exist on the origin side to tell the origin > * when it can skip (re-)sending the datatype. On the target > * side the datatype will be fully allocated for each origin. > * Because a node may be both an origin at one time and > * a target at another, cache entries must be separated since > * the handles in the two cases might match but do not indicate > * the same datatype. Entries that are origin side dataypes have > * the (target) rank with the high bit set. This prevents a > * collision between local datatypes we send to that target > * and foreign datatypes sent to us from that target. > * > * Datatype transfers are done in two sends. > * > * - The first send > * consists of the \e MPID_Type_map structure, as generated on > * the origin node. > * - The second send is the datatype's \e DLOOP_VECTOR, which > * defines the contiguous, type-less, regions. > * > * The actual (original) map and iovec are created/stored in a cache entry > * under the origin node. Since the origin node never talks to itself, > * this cache entry will never conflict with any remote datatype caching. > * > * Before any sends are done on the origin node, an attempt is made > * to create a new cache entry for this datatype/target rank pair. > * If this succeeds, then the datatype has not been sent to the > * target before and so will be sent now. Otherwise the entire > * transfer of the datatype will be skipped. > * > * When the target node receives the first send, the callback > * attempts to create a datatype cache entry for the datatype/origin > * pair. Then a handle-object is created and a receive is setup > * into the handle-object map buffer. > * > * When the target node receives the second send, the callback > * allocates a buffer for the iovec. It then sets up to > * receive into the dataloop buffer. > * > * In order to facilitate/optimize cache flushing, a remote (target) > * node always receives a datatype that is sent, even if it already > * has a cache entry (i.e. it overwrites any existing cache data). > * This means that the origin node must only flush its own, local, cache > * when a datatype goes away, and if/when a new datatype uses the > * same handle then the target side will get a new copy and replace > * the old one. > */ > > /** > * \brief Remove a datatype cache entry > * > * \param[in] dtp Pointer to MPID_Datatype object to un-cache > * \return nothing > */ > void MPIDU_dtc_free(MPID_Datatype *dtp); > > #ifdef NOT_USED > /** > * \brief Get Datatype info for a foreign datatype > * > * Lookup a foreign (remote, origin) datatype in local cache. > * Uses origin lpid and (foreign) datatype. > * > * \param[in] lpid Rank of origin > * \param[in] fdt Foreign (origin) datatype handle to search for > * \param[out] dti Pointer to datatype info struct > * \return 0 if locally cached datatype found, > * or 1 if not found. > * > * \ref dtcache_design > */ > int MPIDU_lookup_dt(int lpid, MPI_Datatype fdt, mpid_dt_info *dti); > #endif /* NOT_USED */ > > /** > * \brief Prepare to receive a foreign datatype (step 1 - map). > * > * Called when MPID_MSGTYPE_DT_MAP (first datatype packet) received. > * Returns NULL if this datatype is already in the cache. > * Since the origin should be mirroring our cache status, > * we would expect to never see this case here. > * Must be the first of sequence: > * - MPID_MSGTYPE_DT_MAP > * - MPID_MSGTYPE_DT_IOV > * - MPID_MSGTYPE_ACC (_PUT, _GET) > * Although, the cache operation is not dependant on any subsequent > * RMA operations - i.e. the caching may be done for its own sake. > * > * Allocates storage for the map and updates cache element. > * > * mpid_info_w0 = MPID_MSGTYPE_MAP > * mpid_info_w1 = map size, bytes > * mpid_info_w2 = origin lpid > * mpid_info_w3 = foreign datatype handle > * mpid_info_w4 = datatype extent > * mpid_info_w5 = datatype element type > * mpid_info_w6 = datatype element size > * mpid_info_w7 = (not used) > * > * \param[in] mi MPIDU_Onesided_info_t containing data > * \return pointer to buffer to receive foreign datatype map > * structure, or NULL if datatype is already cached. > * > * \ref dtcache_design > */ > char *MPID_Prepare_rem_dt(MPIDU_Onesided_info_t *mi); > > #ifdef NOT_USED > /** > * \brief Prepare to update foreign datatype (step 2 - iov). > * > * Called when MPID_MSGTYPE_DT_IOV (second datatype packet) received. > * Returns NULL if this datatype is already in the cache. > * Must be the second of sequence: > * - MPID_MSGTYPE_DT_MAP > * - MPID_MSGTYPE_DT_IOV > * - MPID_MSGTYPE_ACC (_PUT, _GET) > * > * Allocates storage for the iov and updates cache element. > * > * \param[in] lpid Rank of origin > * \param[in] fdt Foreign (origin) datatype handle to search for > * \param[in] dlz iov size (number of elements) > * \return pointer to buffer to receive foreign datatype iov > * structure, or NULL if datatype is already cached. > * > * \ref dtcache_design > */ > char *mpid_update_rem_dt(int lpid, MPI_Datatype fdt, int dlz); > #endif /* NOT_USED */ > > /** > * \brief completion for datatype cache messages (map and iov) > * > * To use this callback, the msginfo (DCQuad) must > * be filled as follows: > * > * - \e w0 - extent size > * - \e w1 - number of elements in map or iov > * - \e w2 - origin rank > * - \e w3 - datatype handle on origin > * > * \param[in] xt Pointer to xtra msginfo saved from original message > * \return nothing > * > */ > void MPID_Recvdone1_rem_dt(const DCQuad *xt); > > #ifdef NOT_USED > /** > * \brief completion for datatype cache messages (map and iov) > * > * To use this callback, the msginfo (DCQuad) must > * be filled as follows: > * > * - \e w0 - MPID_MSGTYPE_DT_IOV > * - \e w1 - number of elements in map or iov > * - \e w2 - origin rank > * - \e w3 - datatype handle on origin > * > * \param[in] xt Pointer to xtra msginfo saved from original message > * \return nothing > * > */ > void mpid_recvdone2_rem_dt(const DCQuad *xt); > #endif /* NOT_USED */ > > /** > * \brief Checks whether a local datatype has already been cached > * at the target node. > * > * Determine whether a local datatype has already been sent to > * this target (and thus is cached over there). > * Returns bool TRUE if datatype is (should be) in lpid's cache. > * > * Should only be called on the origin. > * > * \param[in] lpid lpid of target > * \param[in] dt Local datatype handle to search for > * \param[out] dti Pointer to datatype info struct > * \return Boolean TRUE if the datatype has already been cached. > * > * \ref dtcache_design > */ > int MPIDU_check_dt(int lpid, MPI_Datatype dt, mpid_dt_info *dti); > > /* > * * * * * Request object (DCMF_Request_t) cache * * * * * > * > * because the request object is larger than a cache line, > * no attempt is made to keep objects cache-aligned, for example > * by padding the header to be the same size as the element or > * padding the element to a cache-line size. > * > * The "piggy-back" data is declared as DCQuad for no special > * reason - it was simply a convenient type that contained > * adequate space. This component is not used directly as > * msginfo in any message layer calls. > * > */ > > /** > * \page rqcache_design Request Object Cache Design > * > * The request cache element consists of a \e DCMF_Request_t > * and a single \e DCQuad that may be used to save context > * between the routine that allocated the request object and the > * callback that frees it. > * > * When a request is allocated, the only value returned is > * a pointer to the \e DCMF_Request_t field of the cache element. > * When a request is freed, the cache must be searched for > * a matching element, which is then moved to the free list. > * Before the element is moved to the free list, the \e DCQuad > * must be copied into a caller-supplied buffer or it will be lost. > * > * Callbacks that involve a request cache element will call > * \e MPIDU_free_req with a \e DCQuad buffer to receive the context > * info, if used. Then the context info is examined and action > * taken accordingly. Common use for the contaxt info is to > * free a buffer involved in a send operation and/or decrement > * a counter to indicate completion. > */ > > /** > * \brief Get a new request object from the resource queue. > * > * If 'bgq' is not NULL, copy data into request cache element, > * otherwise zero the field. > * Returns pointer to the request component of the cache element. > * > * \param[in] bgq Optional pointer to additional info to save > * \param[out] info Optional pointer to private info to use > * \return Pointer to DCMF request object > * > * \ref rqcache_design > */ > DCMF_Request_t *MPIDU_get_req(const DCQuad *bgq, > MPIDU_Onesided_info_t **info); > > /** > * \brief Release a DCMF request object and retrieve info > * > * Locate the request object in the request cache and free it. > * If 'bgq' is not NULL, copy piggy-back data into 'bgp'. > * Assumes request object was returned by a call to MPIDU_get_req(). > * > * \param[in] req Pointer to DCMF request object being released > * \param[out] bgq Optional pointer to receive saved additional info > * \return nothing > * > * \ref rqcache_design > */ > void MPIDU_free_req(DCMF_Request_t *req, DCQuad *bgq); > > /* > * * * * * * Callbacks used on request cache objects * * * * * > */ > > /** > * \brief Generic request cache done callback with counter decr > * > * Callback for decrementing a "done" or pending count. > * > * To use this callback, the "xtra" info (DCQuad) must > * be filled as follows: > * > * - \e w0 - (int *) pending counter > * - \e w1 - ignored > * - \e w2 - ignored > * - \e w3 - ignored > * > * \param[in] v Pointer to DCMF request object > * \return nothing > * > * \ref rqcache_design > */ > void done_rqc_cb(void *v); > > #ifdef NOT_USED > /** > * \brief Generic request cache done callback with counter decr > * and 2-buffer freeing. > * > * Callback for decrementing a "done" or pending count and > * freeing malloc() memory, up to two pointers. > * > * To use this callback, the "xtra" info (DCQuad) must > * be filled as follows: > * > * - \e w0 - (int *) pending counter > * - \e w1 - ignored > * - \e w2 - (void *) allocated memory if not NULL > * - \e w3 - (void *) allocated memory if not NULL > * > * \param[in] v Pointer to DCMF request object > * \return nothing > * > * \ref rqcache_design > */ > void done_free_rqc_cb(void *v); > #endif /* NOT_USED */ > > /** > * \brief request cache done callback for Get, with counter decr, > * ref count, buffer freeing and dt release when ref count reaches zero. > * Also uses dt to unpack results into application buffer. > * > * Callback for decrementing a "done" or pending count and > * freeing malloc() memory, up to two pointers, when ref count goes 0. > * > * To use this callback, the "xtra" info (DCQuad) must > * be filled as follows: > * > * - \e w0 - (int *) pending counter > * - \e w1 - (int *) get struct > * - \e w2 - (void *) allocated memory if not NULL > * - \e w3 - (void *) allocated memory if not NULL > * > * \param[in] v Pointer to DCMF request object > * \return nothing > * > * \ref rqcache_design > */ > void done_getfree_rqc_cb(void *v); > > /** > * \brief Generic request cache done callback with counter decr, > * ref count, and 2-buffer freeing when ref count reaches zero. > * > * Callback for decrementing a "done" or pending count and > * freeing malloc() memory, up to two pointers, when ref count goes 0. > * > * To use this callback, the "xtra" info (DCQuad) must > * be filled as follows: > * > * - \e w0 - (int *) pending counter > * - \e w1 - (int *) reference counter > * - \e w2 - (void *) allocated memory if not NULL > * - \e w3 - (void *) allocated memory if not NULL > * > * \param[in] v Pointer to DCMF request object > * \return nothing > * > * \ref rqcache_design > */ > void done_reffree_rqc_cb(void *v); > > #ifdef NOT_USED > /** > * \brief Callback for freeing malloc() memory, up to two pointers. > * > * To use this callback, the "xtra" info (DCQuad) must > * be filled as follows: > * > * - \e w0 - (void *) allocated memory if not NULL > * - \e w1 - (void *) allocated memory if not NULL > * - \e w2 - ignored > * - \e w3 - ignored > * > * \param[in] v Pointer to DCMF request object > * \return nothing > * > * \ref rqcache_design > */ > void free_rqc_cb(void *v); > #endif /* NOT_USED */ > > /** > * \brief Callback invoked to count an RMA operation received > * > * Increments window's \e my_rma_recvs counter. > * If window lock is held, then also increment RMA counter > * for specific origin node, and check whether this RMA op > * completes the epoch and an unlock is waiting to be processed. > * > * We use \e rma_sends to count received RMA ops because we > * know we won't be using that to count sent RMA ops since > * we cannot be in an access epoch while in a LOCK exposure epoch. > * > * Called from both the "long message" completion callbacks and > * the "short message" receive callback, in case of PUT or > * ACCUMULATE only. > * > * \param[in] win Pointer to MPID_Win object > * \param[in] orig Rank of originator of RMA operation > * \param[in] lpid lpid of originator of RMA operation > * \return nothing > */ > void rma_recvs_cb(MPID_Win *win, int orig, int lpid); > > /** > * \brief Generic request cache callback for RMA op completion > * > * Callback for incrementing window RMA recvs count. > * Used only by Put and Accumulate (not used by Get). > * > * Only used for a "long message" - i.e. multi-packet - PUT. > * > * To use this callback, the "xtra" info (DCQuad) must > * be filled as follows: > * > * - \e w0 - ignored > * - \e w1 - window handle > * - \e w2 - origin rank > * - \e w3 - origin lpid > * > * \param[in] v Pointer to DCMF request object > * \return nothing > * > * \ref rqcache_design > */ > void rma_rqc_cb(void *v); > > /** > * \brief Generic callback for request cache > * > * Callback for simply (only) freeing the request cache object. > * > * To use this callback, the "xtra" info (DCQuad) must > * be filled as follows: > * > * - \e w0 - ignored > * - \e w1 - ignored > * - \e w2 - ignored > * - \e w3 - ignored > * > * \param[in] v Pointer to DCMF request object > * \return nothing > * > * \ref rqcache_design > */ > void none_rqc_cb(void *v); > > #ifdef NOT_USED > /** > * \brief Generic send done callback > * > * Local send callback. > * > * Simple "done" callback, currently used only by lock/unlock. > * Assumes param is an int * and decrements it. > * > * \param[in] v Pointer to integer counter to decrement > * \return nothing > */ > void done_cb(void *v); > #endif /* NOT_USED */ > > /** > * \brief receive callback for datatype cache messages (map and iov) > * > * \param[in] v Pointer to request object used for transfer > * \return nothing > */ > void dtc1_rqc_cb(void *v); > > #ifdef NOT_USED > /** > * \brief receive callback for datatype cache messages (map and iov) > * > * \param[in] v Pointer to request object used for transfer > * \return nothing > */ > void dtc2_rqc_cb(void *v); > #endif /* NOT_USED */ > > /* > * * * * * * * * * * * * * * * * * * * * * * > */ > > /** > * \brief Return communicator's VCR table to use for translations > * > * \param[in] c Pointer to communicator object > * \return VCR table to use for rank translations > * > * \todo Confirm this: we only ever talk to remote nodes, > * so always use (c)->vcr (?). > */ > static inline MPID_VCR *MPIDU_world_vcr_c(MPID_Comm *c) { > return (c)->vcr; > } > > /** > * \brief Convert comm rank to world rank > * > * \param[in] c Pointer to communicator object > * \param[in] r Rank of node in window > * \return World rank (lpid) of node > * > * \todo Confirm this: we only ever talk to remote nodes, > * so always use (c)->vcr (?). > */ > static inline int MPIDU_world_rank_c(MPID_Comm *c, int r) { > MPID_VCR *vc; > vc = MPIDU_world_vcr_c(c); > return vc[r]->lpid; > } > > /** > * \brief Return the active size of a communicator > * > * For inter-comms, we will only talk to the remote side so > * return that size. Otherwise, use the local size. > * > * \param[in] c Pointer to communicator object > * \return Size of communicator that we will talk to > */ > static inline int MPIDU_comm_size_c(MPID_Comm *c) { > return ((c)->comm_kind == MPID_INTERCOMM ? > (c)->remote_size : > (c)->local_size); > } > > /** > * \brief Convert window rank to world rank > * > * Used in MPID_Win_{lock|put|get|accumulate} to get the > * COMM_WORLD rank of a window-comm rank in order to get > * the destination parameter of a DCMF_ operation. > * > * Assumes MPID_Win_* might be called with an intercomm. > * > * Note, MPIDU_proto_send() does not call this since it > * ends up getting the COMM_WORLD rank as a result of the > * group-to-window-comm rank translation. > * > * \param[in] w Pointer to MPID_Win object > * \param[in] r Rank of node in window > * \return World rank (lpid) of node > */ > #define MPIDU_world_rank(w, r) MPIDU_world_rank_c((w)->_dev.comm_ptr, r) > > /** > * \brief Return the VCR of a window's communicator > * > * \param[in] w Pointer to MPID_Win object > * \return VCR table to use for rank translations > */ > #define MPIDU_world_vcr(w) MPIDU_world_vcr_c((w)->_dev.comm_ptr) > > /** > * \brief Return the active size of a window's communicator > * > * \param[in] w Pointer to MPID_Win object > * \return Size of communicator > */ > #define MPIDU_comm_size(w) MPIDU_comm_size_c((w)->_dev.comm_ptr) > > /** > * \brief Send (spray) a protocol message to a group of nodes. > * > * Send a protocol message to all members of a group (or the > * window-comm if no group). > * > * Currently, this routine will only be called once per group > * (i.e. once during an exposure or access epoch). If it ends > * up being called more than once, it might make sense to build > * a translation table between the group rank and the window > * communicator rank. Or if we can determine that the same > * group is being used in multiple, successive, epochs. In practice, > * it takes more work to build a translation table than to lookup > * ranks ad-hoc. > * > * \param[in] win Pointer to MPID_Win object > * \param[in] grp Optional pointer to MPID_Group object > * \param[in] type Type of message (MPID_MSGTYPE_*) > * \return MPI_SUCCESS or error returned from DCMF_Send. > * > * \ref msginfo_usage > */ > int MPIDU_proto_send(MPID_Win *win, MPID_Group *grp, int type); > > /** > * \brief Utility routine to provide accumulate function on target. > * > * Utility routine to provide accumulate function on target. > * > * Called from "long message" ACCUMULATE completion callback > * or "short message" ACCUMULATE receive callback. > * > * \param[in] win Pointer to MPID_Win object > * \param[in] dst Pointer to destination buffer > * \param[in] src Pointer to source buffer > * \param[in] rank Rank of origin > * \param[in] fdt Foreign datatype > * \param[in] op Operand > * \param[in] num number of Foreign datatype elements > * \return nothing > */ > void target_accumulate(MPIDU_Onesided_info_t *mi, > const char *src, int lpid); > > /* > * * * * * * * * * * * * * * * * * * * * * * > */ > > /** > * \brief validate whether a lpid is in a given group > * > * Searches the group lpid list for a match. > * > * \param[in] lpid World rank of the node in question > * \param[in] grp Group to validate against > * \return TRUE is lpid is in group > */ > int MPIDU_valid_group_rank(int lpid, MPID_Group *grp); > > /** > * \brief Test whether a window is in an RMA access epoch > * > * Assert that the local window is in the proper mode to receive > * RMA operations. > * > * \note One cause of this to fail is improper use of MPI_MODE_NOPUT. > * > * \param[in] w Pointer to window object > * \return TRUE if RMA ops are allowed > */ > #define MPIDU_assert_RMAOK(w) MPID_assert((w)->_dev.epoch_rma_ok) > /** > * \brief Test whether a window is in an RMA access epoch > * > * Assert that the local window is in the proper mode to receive > * RMA operations. > * > * \note One cause of this to fail is improper use of MPI_MODE_NOPUT. > * Another is erroneous use of MPI_MODE_NOCHECK. > * > * \param[in] w Pointer to window object > * \return TRUE if PUT/ACCUMULATE ops are allowed > */ > #define MPIDU_assert_PUTOK(w) MPID_assert((w)->_dev.epoch_rma_ok && \ > !((w)->_dev.epoch_assert & MPI_MODE_NOPUT)) > > /** > * \brief validate that an RMA target is legitimate for the epoch type > * > * For MPID_EPOTYPE_LOCK requires target to be the same as that > * used in the MPID_Win_lock call. > * > * For MPID_EPOTYPE_FENCE allows any target, > * assuming that the target was validated against comm_ptr > * by the MPI layer. > * > * For MPID_EPOTYPE_*START valids the rank against group_ptr. > * > * \todo Is this check too expensive to be done on every RMA? > * > * \param[in] w Window > * \param[in] r Rank > * \return TRUE if rank is valid for current epoch > */ > #define MPIDU_VALID_RMA_TARGET(w, r) \ > (((w)->_dev.epoch_type == MPID_EPOTYPE_LOCK && \ > (w)->_dev.epoch_size == (r)) || \ > (w)->_dev.epoch_type == MPID_EPOTYPE_FENCE || \ > (((w)->_dev.epoch_type == MPID_EPOTYPE_START || \ > (w)->_dev.epoch_type == MPID_EPOTYPE_POSTSTART) && \ > MPIDU_valid_group_rank(MPIDU_world_rank(w, r), \ > (w)->start_group_ptr))) > > /* > * Remote (receiver) Callbacks. > */ > > /** > * \brief Receive callback for RMA protocol and operations messages > * > * "Small" message callback - the entire message is already here. > * Process it now and return. > * > * \param[in] _mi Pointer to msginfo > * \param[in] ct Number of DCQuad's in msginfo > * \param[in] or Rank of origin > * \param[in] sb Pointer to send buffer (data received) > * \param[in] sl Length (bytes) of data > * \return nothing > * > * \ref msginfo_usage > */ > void recv_sm_cb(void *cd, const DCQuad *_mi, unsigned ct, unsigned or, > const char *sb, const unsigned sl); > > /** > * \brief Callback for DCMF_Control() messages > * > * Simple pass-through to recv_sm_cb() with zero-length data. > * > * \param[in] ctl Control message (one quad) > * \param[in] or Origin node lpid > * \return nothing > */ > void recv_ctl_cb(void *cd, const DCMF_Control_t *ctl, unsigned or); > > /** > * \brief Callback for Accumulate recv completion > * > * "Message receive completion" callback used for MPID_MSGTYPE_ACC > * to implement the accumulate function. Decodes data from request > * cache object, frees request, does accumulate, and updates RMA count. > * > * Used for "long message" ACCUMULATE. > * > * To use this callback, the "xtra" info (DCQuad) must > * be filled as follows: > * > * - \e w0 - ignored > * - \e w1 - ignored > * - \e w2 - (int *)multi-struct buffer (int *, DCQuad[], data) > * - \e w3 - origin lpid > * > * \param[in] v Pointer to DCMF request object > * \return nothing > * > * \ref msginfo_usage > */ > void accum_cb(void *v); > > /** > * \brief Receive callback for RMA operations messages > * > * "Message receive initiated" callback. > * This one should never get called for protocol messages. > * Setup buffers, get a request object, and return so receive can begin. > * In some cases (e.g. MPID_MSGTYPE_ACC) the processing is done in the > * receive completion callback, otherwise that callback just frees > * the request and cleans up (updates counters). > * > * \param[in] _mi Pointer to msginfo > * \param[in] ct Number of DCQuad's in msginfo > * \param[in] or Rank of origin > * \param[in] sl Length (bytes) of sent data > * \param[out] rl Length (bytes) of data to receive > * \param[out] rb receive buffer > * \param[out] cb callback to invoke after receive > * \return Pointer to DCMF request object to use for receive, > * or NULL to discard received data > * > * \ref msginfo_usage > */ > DCMF_Request_t *recv_cb(void *cd, const DCQuad *_mi, unsigned ct, > unsigned or, const unsigned sl, unsigned *rl, > char **rb, DCMF_Callback_t *cb); > > void mpidu_init_lock(MPID_Win *win); > void mpidu_free_lock(MPID_Win *win); > > /** > * \brief Lock receive callback. > * > * Attempts to acquire the lock. > * On success, sends ACK to origin. > * On failure to acquire lock, > * adds caller to lock wait queue. > * > * Does not attempt to acquire lock (counted as failure) > * if window is currently in some other epoch. > * > * \param[in] info Pointer to msginfo from origin (locker) > * \param[in] lpid lpid of origin node (locker) > * \return nothing > * > * \ref msginfo_usage\n > * \ref lock_design > */ > void lock_cb(const MPIDU_Onesided_ctl_t *info, int lpid); > > /** > * \brief Epoch End callback. > * > * Called whenever epoch_type is set to MPID_EPOTYPE_NONE, i.e. an > * access/exposure epoch ends. Also called when the window lock is > * released (by the origin node). > * > * This is used to prevent locks from being acquired while some other > * access/exposure epoch is active on a window, and queues the lock > * attempt until such time as the epoch has ended. > * > * \param[in] win Pointer to MPID_Win whose epoch has ended > */ > void epoch_end_cb(MPID_Win *win); > > /** > * \brief Unlock receive callback. > * > * Attempts to release the lock. > * If the lock cannot be released (due to outstanding RMA ops not > * yet received) then the unlocker is placed on a queue where its > * request will be re-evaluated when RMA ops are received. > * If lock can be released, any lock waiters are woken up in > * \e epoch_end_cb() and an MPID_MSGTYPE_UNLOCKACK is sent to the unlocker. > * > * \param[in] info Pointer to msginfo from origin (unlocker) > * \param[in] lpid lpid of origin node (unlocker) > * \return nothing > * > * \ref msginfo_usage\n > * \ref lock_design > */ > void unlk_cb(const MPIDU_Onesided_ctl_t *info, int lpid); > > /* > * End of remote callbacks. > */ > > #ifdef NOT_USED > /** > * \brief Send local datatype to target node > * > * Routine to send target datatype to target node. > * These sends are handled by recv callbacks above... > * > * \param[in] dt datatype handle to send > * \param[in] o_lpid Origin lpid > * \param[in] t_lpid Target lpid > * \param[out] pending Pointer to send done counter > * \param[in,out] consistency Pointer for consistency used for sends (out) > * \return MPI_SUCCESS, or error returned by DCMF_Send. > * > * \ref msginfo_usage\n > * \ref dtcache_design > */ > int mpid_queue_datatype(MPI_Datatype dt, > int o_lpid, int t_lpid, volatile unsigned *pending, > DCMF_Consistency *consistency); > #endif /* NOT_USED */ > > /* > * End of utility routines > * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * > */ diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/onesided/mpid_put.c bgp-mpich2/src/mpid/dcmf/src/onesided/mpid_put.c 0a1,232 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file src/onesided/mpid_put.c > * \brief MPI-DCMF MPI_Put functionality > */ > > #include "mpid_onesided.h" > > /** > * \page put_design MPID_Put Design > * > * Origin node calls MPI_Put > * > * - A sanity-check is done to > * ensure that the window is in a valid state to initiate > * a put RMA operation. > * These checks include testing that > * the epoch currently in affect is not \e NONE or \e POST. > * - If target rank is origin rank, call MPIR_Localcopy. > * - If origin datatype is not contiguous, allocate a buffer > * for contiguous data and pack the local data into it. > * - This allocation includes a reference count which is used > * in the send callbacks to determine when the buffer can be freed. > * - If target datatype is contiguous, put data from local buffer > * into target window buffer. > * - If target datatype is non-contiguous: > * - Create IO Vector from target datatype. > * - Perform multiple put's from local buffer into target window > * buffer segments. > * - Wait for all sends to go. > * - If no sends were initiated, and origin datatype non-contiguous, > * free the buffer. > */ > /// \cond NOT_REAL_CODE > #undef FUNCNAME > #define FUNCNAME MPID_Put > #undef FCNAME > #define FCNAME MPIU_QUOTE(FUNCNAME) > /// \endcond > /** > * \brief MPI-DCMF glue for MPI_PUT function > * > * Put \e origin_count number of \e origin_datatype from \e origin_addr > * to node \e target_rank into \e target_count number of \e target_datatype > * into window location \e target_disp offset (window displacement units) > * > * \param[in] origin_addr Source buffer > * \param[in] origin_count Number of datatype elements > * \param[in] origin_datatype Source datatype > * \param[in] target_rank Destination rank (target) > * \param[in] target_disp Displacement factor in target buffer > * \param[in] target_count Number of target datatype elements > * \param[in] target_datatype Destination datatype > * \param[in] win_ptr Window > * \return MPI_SUCCESS, MPI_ERR_RMA_SYNC, or error returned from > * MPIR_Localcopy, MPID_Segment_init, or DCMF_Send. > * > * \ref msginfo_usage\n > * \ref put_design > */ > int MPID_Put(void *origin_addr, int origin_count, > MPI_Datatype origin_datatype, int target_rank, > MPI_Aint target_disp, int target_count, > MPI_Datatype target_datatype, MPID_Win *win_ptr) > { > int mpi_errno = MPI_SUCCESS; > int dt_contig, rank; > MPID_Datatype *dtp; > MPI_Aint dt_true_lb; > MPIDI_msg_sz_t data_sz; > MPIU_THREADPRIV_DECL; > MPID_MPI_STATE_DECL(MPID_STATE_MPID_PUT); > > MPID_MPI_FUNC_ENTER(MPID_STATE_MPID_PUT); > MPIU_THREADPRIV_GET; > MPIR_Nest_incr(); > > if (win_ptr->_dev.epoch_type == MPID_EPOTYPE_NONE || > win_ptr->_dev.epoch_type == MPID_EPOTYPE_POST || > !MPIDU_VALID_RMA_TARGET(win_ptr, target_rank)) { > /* --BEGIN ERROR HANDLING-- */ > MPIU_ERR_SETANDSTMT(mpi_errno, MPI_ERR_RMA_SYNC, > goto fn_fail, "**rmasync"); > /* --END ERROR HANDLING-- */ > } > > MPIDI_Datatype_get_info(origin_count, origin_datatype, > dt_contig, data_sz, dtp, dt_true_lb); > if ((data_sz == 0) || (target_rank == MPI_PROC_NULL)) { > goto fn_exit; > } > rank = win_ptr->_dev.comm_ptr->rank; > > /* If the put is a local operation, do it here */ > if (target_rank == rank) { > if (win_ptr->_dev.epoch_type == MPID_EPOTYPE_LOCK && > MPIDU_is_lock_free(win_ptr)) { > /* --BEGIN ERROR HANDLING-- */ > MPIU_ERR_SETANDSTMT(mpi_errno, MPI_ERR_RMA_SYNC, > goto fn_fail, "**rmasync"); > /* --END ERROR HANDLING-- */ > } > mpi_errno = MPIR_Localcopy(origin_addr, origin_count, > origin_datatype, > (char *)win_ptr->base + > win_ptr->disp_unit * > target_disp, > target_count, target_datatype); > if (mpi_errno) { MPIU_ERR_POP(mpi_errno); } > } else { > /* queue it up */ > DCMF_Callback_t cb_send; > int *refp = NULL; > DCMF_Request_t *reqp; > int t_dt_contig; > MPID_Datatype *t_dtp; > MPI_Aint t_dt_true_lb; > MPIDI_msg_sz_t t_data_sz; > MPID_Segment segment; > mpid_dt_info dti; > int i, j, last, sent = 0; > char *b, *s, *buf; > MPIDU_Onesided_info_t *info; > int lpid; > DCQuad xtra = {0}; > > lpid = MPIDU_world_rank(win_ptr, target_rank); > MPIDI_Datatype_get_info(target_count, target_datatype, > t_dt_contig, t_data_sz, t_dtp, t_dt_true_lb); > /* NOTE! t_data_sz already is adjusted for target_count */ > > if (dt_contig) { > buf = origin_addr; > cb_send.function = done_rqc_cb; > } else { > MPIDU_MALLOC(buf, char, data_sz + sizeof(int), mpi_errno, "MPID_Put"); > if (buf == NULL) { > MPID_Abort(NULL, MPI_ERR_NO_SPACE, -1, > "Unable to allocate " > "non-contiguous buffer"); > } > refp = (int *)buf; > xtra.w1 = (unsigned)refp; > xtra.w2 = (unsigned)buf; > cb_send.function = done_reffree_rqc_cb; > buf += sizeof(int); > *refp = 0; > mpi_errno = MPID_Segment_init(origin_addr, > origin_count, > origin_datatype, &segment, 0); > if (mpi_errno) { MPIU_ERR_POP(mpi_errno); } > last = data_sz; > MPID_Segment_pack(&segment, 0, &last, buf); > MPID_assert_debug(last == data_sz); > } > xtra.w0 = (unsigned)&win_ptr->_dev.my_rma_pends; > if (t_dt_contig) { > reqp = MPIDU_get_req(&xtra, &info); > info->mpid_info_w0 = MPID_MSGTYPE_PUT; > info->mpid_info_w1 = win_ptr->_dev.coll_info[target_rank].win_handle; > info->mpid_info_w2 = rank; > info->mpid_info_w3 = (unsigned)win_ptr->_dev.coll_info[target_rank].base_addr + > win_ptr->_dev.coll_info[target_rank].disp_unit * target_disp; > cb_send.clientdata = reqp; > ++win_ptr->_dev.my_rma_pends; > if (refp) { ++*refp; } > ++sent; > mpi_errno = DCMF_Send(&bg1s_sn_proto, reqp, > cb_send, win_ptr->_dev.my_cstcy, lpid, > t_data_sz, buf, > info->info, 2); > if (mpi_errno) { MPIU_ERR_POP(mpi_errno); } > ++win_ptr->_dev.coll_info[target_rank].rma_sends; > } else { > /* force map to get built but don't assume > * it was sent (use our lpid) */ > (void)MPIDU_check_dt(mpid_my_lpid, target_datatype, &dti); > MPID_assert(dti.map != NULL); > xtra.w1 = (unsigned)&win_ptr->_dev.my_rma_pends; > b = win_ptr->_dev.coll_info[target_rank].base_addr + > win_ptr->_dev.coll_info[target_rank].disp_unit * > target_disp; > s = buf; > if (refp) *refp = target_count * dti.map_len; > for (j = 0; j < target_count; ++j) { > for (i = 0; i < dti.map_len; i++) { > MPIDU_Progress_spin(win_ptr->_dev.my_rma_pends > > MPIDI_Process.rma_pending); > reqp = MPIDU_get_req(&xtra, &info); > info->mpid_info_w0 = MPID_MSGTYPE_PUT; > info->mpid_info_w1 = win_ptr->_dev.coll_info[target_rank].win_handle; > info->mpid_info_w2 = rank; > info->mpid_info_w3 = (unsigned)b + dti.map[i].off; > cb_send.clientdata = reqp; > ++win_ptr->_dev.my_rma_pends; > ++sent; > mpi_errno = DCMF_Send(&bg1s_sn_proto, > reqp, cb_send, > win_ptr->_dev.my_cstcy, lpid, > dti.map[i].len, s, > info->info, 2); > if (mpi_errno) { MPIU_ERR_POP(mpi_errno); } > ++win_ptr->_dev.coll_info[target_rank].rma_sends; > s += dti.map[i].len; > } > b += dti.dtp->extent; > } > } > /* TBD: someday this will be done elsewhere */ > MPIDU_Progress_spin(win_ptr->_dev.my_rma_pends > 0); > if (sent == 0 && xtra.w2) { > MPIDU_FREE(xtra.w2, mpi_errno, "MPID_Put"); > } > } > > fn_exit: > MPIR_Nest_decr(); > MPID_MPI_FUNC_EXIT(MPID_STATE_MPID_PUT); > return mpi_errno; > > /* --BEGIN ERROR HANDLING-- */ > fn_fail: > goto fn_exit; > /* --END ERROR HANDLING-- */ > } diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/onesided/mpid_rma_common.c bgp-mpich2/src/mpid/dcmf/src/onesided/mpid_rma_common.c 0a1,1816 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file src/onesided/mpid_rma_common.c > * \brief MPI-DCMF Code and data common to RMA modules > */ > > #include "mpid_onesided.h" > > #if 0 > char *msgtypes[] = { > [MPID_MSGTYPE_NONE] = "MPID_MSGTYPE_NONE", > [MPID_MSGTYPE_LOCK] = "MPID_MSGTYPE_LOCK", > [MPID_MSGTYPE_UNLOCK] = "MPID_MSGTYPE_UNLOCK", > [MPID_MSGTYPE_POST] = "MPID_MSGTYPE_POST", > [MPID_MSGTYPE_START] = "MPID_MSGTYPE_START", > [MPID_MSGTYPE_COMPLETE] = "MPID_MSGTYPE_COMPLETE", > [MPID_MSGTYPE_WAIT] = "MPID_MSGTYPE_WAIT", > [MPID_MSGTYPE_FENCE] = "MPID_MSGTYPE_FENCE", > [MPID_MSGTYPE_UNFENCE] = "MPID_MSGTYPE_UNFENCE", > [MPID_MSGTYPE_PUT] = "MPID_MSGTYPE_PUT", > [MPID_MSGTYPE_GET] = "MPID_MSGTYPE_GET", > [MPID_MSGTYPE_ACC] = "MPID_MSGTYPE_ACC", > [MPID_MSGTYPE_DT_MAP] = "MPID_MSGTYPE_DT_MAP", > [MPID_MSGTYPE_DT_IOV] = "MPID_MSGTYPE_DT_IOV", > [MPID_MSGTYPE_LOCKACK] = "MPID_MSGTYPE_LOCKACK", > [MPID_MSGTYPE_UNLOCKACK] = "MPID_MSGTYPE_UNLOCKACK", > }; > #endif > > /** \brief DCMF Protocol object for DCMF_Send() calls */ > DCMF_Protocol_t bg1s_sn_proto; > /** \brief DCMF Protocol object for DCMF_Get() calls */ > DCMF_Protocol_t bg1s_gt_proto; > /** \brief DCMF Protocol object for DCMF_Control() calls */ > DCMF_Protocol_t bg1s_ct_proto; > > /** > * \page msginfo_usage Message info (DCQuad) usage conventions > * > * First (or only) quad: > * - \e w0 = Message type (MPID_MSGTYPE_*) > * - \e w1 = (target) window handle > * (except Datatype map/iov messages use num elements) > * - \e w2 = (originating) rank > * - \e w3 = Depends on message type: > * > * > * > * > * > * > * > * > * > *
Epoch End:RMA send count
Put/Accumulate:target memory address
Lock:lock type
Datatype/loop:datatype (handle on origin)
> * > * Additional quads are message-specific > * > * MPID_MSGTYPE_ACC: > * - \e w0 = target datatype (handle on origin) > * - \e w1 = operand handle (must be builtin) > * - \e w2 = length (number of datatype instances) > * - \e w3 = 0 > * > * \note Epoch End includes MPID_MSGTYPE_UNLOCK and MPID_MSGTYPE_COMPLETE > * (MPID_Win_fence() uses NMPI_Allreduce()). > */ > > /** \brief global for our lpid */ > unsigned mpid_my_lpid = -1; > > /** > * \brief Build datatype map and iovec > * > * \param[in] dt Datatype to build map/iov for > * \param[out] dti Pointer to datatype info struct > */ > void make_dt_map_vec(MPI_Datatype dt, mpid_dt_info *dti) { > int nb, last; > MPID_Segment seg; > MPID_Type_map *mv; > DLOOP_VECTOR *iv; > int i; > MPI_Datatype eltype; > unsigned size; > MPID_Datatype *dtp; > /* NOTE: we know "dt" is not builtin, else why do this? */ > > /* Use existing routines to get IOV */ > > MPID_Datatype_get_ptr(dt, dtp); > nb = dtp->n_contig_blocks + 1; > > MPIDU_MALLOC(mv, MPID_Type_map, nb * sizeof(*mv), last, "MPID_Type_map"); > MPID_assert(mv != NULL); > iv = (DLOOP_VECTOR *)mv; > MPID_Segment_init(NULL, 1, dt, &seg, 0); > last = dtp->size; > MPID_Segment_pack_vector(&seg, 0, &last, iv, &nb); > if (HANDLE_GET_KIND(dtp->eltype) == HANDLE_KIND_BUILTIN) { > eltype = dtp->eltype; > size = MPID_Datatype_get_basic_size(eltype); > } else { > eltype = 0; > size = 0; /* don't care */ > } > /* This works because we go backwards, and DLOOP_VECTOR << MPID_Type_map */ > for (i = nb; i > 0; ) { > --i; > mv[i].off = (unsigned)iv[i].DLOOP_VECTOR_BUF; > mv[i].len = iv[i].DLOOP_VECTOR_LEN; > mv[i].num = (eltype ? mv[i].len / size : 0); > mv[i].dt = eltype; > } > dti->map_len = nb; > dti->map = mv; > dti->dtp = dtp; > } > > /** > * \brief Datatype created to represent the rma_sends element > * of the coll_info array of the window structure > */ > MPI_Datatype Coll_info_rma_dt; > /** > * \brief User defined function created to process the rma_sends > * elements of the coll_info array of the window structure > */ > MPI_Op Coll_info_rma_op; > > /** > * \brief Dummy, global, MPID_Progress_state since its not used. > */ > MPID_Progress_state dummy_state; > > /* > * * * * * Generic resource pool management * * * * * > */ > > /** > * \page rsrc_design Basic resource element design > * > * Generic resources are managed through a \e mpid_qhead structure > * which defines the basic geometry of the allocation blocks and > * references the first allocated block. > * > * Generic resources are allocated in blocks. Each block begins > * with a header of \e mpid_resource and is followed by a number > * of elements whose size and count are defined for each resource > * type. Also, the header size is defined, which may be larger > * than the natural size of \e mpid_resource in order to optimize > * memory layout (i.e. cache usage). > * > * Resource blocks are never freed (exception: lock wait queue > * resources are freed when the window is freed). > * > * Specific resources are defined by their elements. Every resource > * element must have as its first field the \e next pointer, as > * defined by \e mpid_element. Following this is > * defined by the needs of the specific resource. > * > * A newly allocated block is initialized with all elements \e next > * chained together and the block's \e next_free pointer set to the > * first (free) element. Except for the first allocated block > * (the one directly referenced by \e mpid_qhead), the \e next_free > * is not used again. This also applies to the \e next_used and > * \e last_used pointers. > * > * A newly allocated secondary block is linked into the \e mpid_qhead > * \e next_block chain and \e next_free chain. > * > * When an element is taken from the free list, it is always taken > * from the top of the list, i.e. directly from \e next_free. > * When an element is returned to the free list, it is placed > * (pushed) on the top. So an element to be allocated is always the > * one most-recently freed, i.e. a LIFO queue. > * > * When an element is added to the used list, it is always added > * to the end of the list, i.e. using the \e last_used pointer. > * If an arbitrary element is taken from the used list, it is > * taken from the top of the list, i.e. using \e next_used. This > * effectively forms a FIFO queue. > * > * Other routines exist that permit the used list to be searched, > * and the found element may be removed from the used list > * "out of turn". A specific resource implementation decides > * how it will use this list. > */ > > /** > * \brief Allocate a new block of elements. > * > * Unconditionally allocates a block of resources as described by > * 'qhead' and link the block into 'qhead'. The new elements > * are added to the 'qhead' free list. The new elements are > * uninitialized except for the mpid_element field(s). > * > * \param[in] qhead Queue Head > * \return nothing > * > * \ref rsrc_design > */ > void MPIDU_alloc_resource(struct mpid_qhead *qhead) { > struct mpid_resource *nq; > struct mpid_element *ne, *nl; > struct mpid_resource *lq; > int x, z; > > z = qhead->hdl + (qhead->num * qhead->len); > MPIDU_MALLOC(nq, struct mpid_resource, z, x, "MPIDU_alloc_resource"); > MPID_assert(nq != NULL); > nq->next_used = NULL; > nq->last_used = NULL; > nq->next_block = NULL; > /* point to last element in block */ > ne = (struct mpid_element *)((char *)nq + z - qhead->len); > nl = NULL; > /* stitch together elements, starting at end */ > for (x = 0; x < qhead->num; ++x) { > ne->next = nl; > nl = ne; > ne = (struct mpid_element *)((char *)ne - qhead->len); > } > nq->next_free = nl; > /* Determine how to append new block to block list */ > if (qhead->blocks == NULL) { > qhead->blocks = nq; > } else { > /* locate end of block list */ > lq = qhead->lastblock; > lq->next_block = nq; > lq = qhead->blocks; /* reset/rewind */ > /* determine how to append new elements to free list */ > if (lq->next_free == NULL) { > lq->next_free = nq->next_free; > } else { > /* locate end of free list */ > for (ne = lq->next_free; ne->next; > ne = ne->next); > ne->next = nq->next_free; > } > } > qhead->lastblock = nq; > } > > /** > * \brief Unconditionally free all resource blocks > * referenced by 'qhead'. > * > * NOTE: elements such as datatype cache require addition freeing > * and so won't work with this. We could add a "free func ptr" to > * qhead and call it here - so each element type can free any other > * buffers it may have allocated. > * > * Right now, this is only called by Win_free() on the lock and unlock > * wait queues, which do no additional allocation. > * > * \param[in] qhead Queue Head > * \return nothing > * > * \ref rsrc_design > */ > void MPIDU_free_resource(struct mpid_qhead *qhead) { > struct mpid_resource *qp, *np; > > for (qp = qhead->blocks; qp != NULL; qp = np) { > np = qp->next_block; > MPIDU_FREE(qp, e, "MPIDU_free_resource"); > } > qhead->blocks = NULL; > } > > /** > * \brief Get a new (unused) resource element. > * > * Take a resource element off the free list and put it on the > * end of used list (bottom of queue). Element is uninitialized > * except for mpid_element structure fields. > * > * \param[in] qhead Queue Head > * \return pointer to element. > * > * \ref rsrc_design > */ > void *MPIDU_get_element(struct mpid_qhead *qhead) { > struct mpid_resource *lq = qhead->blocks; > struct mpid_element *wp; > > if (lq == NULL || lq->next_free == NULL) { > MPIDU_alloc_resource(qhead); > lq = qhead->blocks; > MPID_assert_debug(lq != NULL && lq->next_free != NULL); > } > wp = lq->next_free; > lq->next_free = wp->next; > if (lq->last_used != NULL) { > lq->last_used->next = wp; > } > wp->next = NULL; > lq->last_used = wp; > if (lq->next_used == NULL) { > lq->next_used = wp; > } > return wp; > } > > /** > * \brief Initialize a new (unused) element. > * > * Get a new element from free list and initialize its contents > * from 'el'. Element is placed at bottom of queue. > * 'el' is assumed to be of qhead->len size. > * > * \param[in] qhead Queue Head > * \param[in] el Pointer to new element data > * \return pointer to element. > * > * \ref rsrc_design > */ > void *MPIDU_add_element(struct mpid_qhead *qhead, void *el) { > struct mpid_element *wp; > > wp = MPIDU_get_element(qhead); > MPID_assert_debug(wp != NULL); > memcpy( (char *)wp + sizeof(struct mpid_element), > (char *)el + sizeof(struct mpid_element), > qhead->len - sizeof(struct mpid_element)); > return wp; > } > > /** > * \brief Peek at top element in queue (used list). > * > * Copy contents of first element in used list (top of queue) > * into 'el'. Does not alter qhead (used or free lists). > * 'el' is assumed to be of qhead->len size. > * > * \param[in] qhead Queue Head > * \param[out] el Pointer to destination for element data > * \return 1 if no elements on queue or > * 0 on success with 'el' filled-in. > * > * \ref rsrc_design > */ > int MPIDU_peek_element(struct mpid_qhead *qhead, void *el) { > struct mpid_resource *lq = qhead->blocks; > > if (lq == NULL || lq->next_used == NULL) { > return 1; > } > if (el != NULL) { > memcpy(el, lq->next_used, qhead->len); > } > return 0; > } > > /** > * \brief Free an element. > * > * Remove element 'el' (parent element 'pe') from used list > * and place on free list. Typically, this is only called > * after calling MPIDU_find_element() to obtain 'el' and 'pe'. > * > * (See MPIDU_free_resource()) This does not take into account > * any additional allocations done by the element type. Whether > * any such buffers need to be freed depends on how the element- > * type re-uses elements (when taken off the free list). > * > * \param[in] qhead Queue Head > * \param[in] el Element object > * \param[in] pe Parent element object, or NULL if 'el' > * is at top of queue. > * \return nothing > * > * \ref rsrc_design > */ > void MPIDU_free_element(struct mpid_qhead *qhead, > void *el, void *pe) { > struct mpid_resource *lq = qhead->blocks; > struct mpid_element *wp = el; > struct mpid_element *pp = pe; > > MPID_assert_debug(lq != NULL && wp != NULL); > /* > * sanity check - 'pp' must be parent of 'wp' > * or 'wp' must be at qhead->next_used. > */ > MPID_assert_debug(pp == NULL || pp->next == wp); > MPID_assert_debug(pp != NULL || lq->next_used == wp); > if (lq->last_used == wp) { > lq->last_used = pp; > } > if (pp) { > pp->next = wp->next; > } else { > lq->next_used = wp->next; > } > wp->next = lq->next_free; > lq->next_free = wp; > } > > /** > * \brief Pop first element off used list (top of queue). > * > * Element contents is copied into 'el', if not NULL. > * Popped element is placed on free list. > * Returns 0 (success) if element was popped, or 1 if list empty. > * > * \param[in] qhead Queue Head > * \param[out] el Element contents buffer > * \return 1 if no elements on queue or > * 0 on success with 'el' filled-in. > * > * \ref rsrc_design > */ > int MPIDU_pop_element(struct mpid_qhead *qhead, void *el) { > struct mpid_element *wp; > struct mpid_resource *lq = qhead->blocks; > > if (lq == NULL || lq->next_used == NULL) { > return 1; > } > wp = lq->next_used; > if (el != NULL) { > memcpy(el, wp, qhead->len); > } > /* we know there was no parent... */ > MPIDU_free_element(qhead, wp, NULL); > return 0; > } > > /** > * \brief Find specific element in queue. > * > * Find element in used list that "matches" according to > * 'func'('el', ...). 'func' is called with arbitrary parameter 'el' > * and pointer to element under test. Only one element is found, > * always the first "match". 'func' returns 0 for match (success). > * > * Returns NULL if no match found. > * If 'parent' is not NULL, returns pointer to parent element there. > * Note, '*parent' == NULL means element is first in list. > * > * \param[in] qhead Queue Head > * \param[in] func Function to use to test for desired element > * \param[in] v3 void arg passed to \e func in 3rd arg > * \param[in] el Static first parameter for 'func' > * \param[in,out] parent Pointer to parent element to start search from; > * Pointer to parent element of match found, > * or NULL if 'el' is at top of queue. > * \return Pointer to element found with 'parent' set, > * or NULL if not found. > * > * \ref rsrc_design > */ > void *MPIDU_find_element(struct mpid_qhead *qhead, > int (*func)(void *, void *, void *), void *v3, void *el, > struct mpid_element **parent) { > struct mpid_element *wp, *pp = NULL; > > if (qhead->blocks == NULL) { > return NULL; > } > wp = (parent && *parent ? (*parent)->next : qhead->blocks->next_used); > if (wp) { > if (!func(el, wp, v3)) { > // we don't remove it here... > //qhead->blocks->next_used = wp->next; > } else { > for (pp = wp; pp->next && func(el, pp->next, v3); > pp = pp->next); > wp = pp->next; > } > } > if (parent) { > *parent = pp; > } > return wp; > } > > /* > * * * * * Remote (origin, foreign) Datatype cache * * * * * > */ > > /** > * \page dtcache_design Datatype Cache Design > * > * The datatype cache element stores the rank, datatype handle > * and the localized datatype object (map and iovec). Builtin > * datatypes are not cached (and not sent). > * > * This cache is used in a split fashion, where "cloned" > * cache entries exist on the origin side to tell the origin > * when it can skip (re-)sending the datatype. On the target > * side the datatype will be fully allocated for each origin. > * Because a node may be both an origin at one time and > * a target at another, cache entries must be separated since > * the handles in the two cases might match but do not indicate > * the same datatype. Entries that are origin side dataypes have > * the (target) rank with the high bit set. This prevents a > * collision between local datatypes we send to that target > * and foreign datatypes sent to us from that target. > * > * Datatype transfers are done in two sends. > * > * - The first send > * consists of the \e MPID_Type_map structure, as generated on > * the origin node. > * - The second send is the datatype's \e DLOOP_VECTOR, which > * defines the contiguous, type-less, regions. > * > * The actual (original) map and iovec are created/stored in a cache entry > * under the origin node. Since the origin node never talks to itself, > * this cache entry will never conflict with any remote datatype caching. > * > * Before any sends are done on the origin node, an attempt is made > * to create a new cache entry for this datatype/target rank pair. > * If this succeeds, then the datatype has not been sent to the > * target before and so will be sent now. Otherwise the entire > * transfer of the datatype will be skipped. > * > * When the target node receives the first send, the callback > * attempts to create a datatype cache entry for the datatype/origin > * pair. Then a handle-object is created and a receive is setup > * into the handle-object map buffer. > * > * When the target node receives the second send, the callback > * allocates a buffer for the iovec. It then sets up to > * receive into the dataloop buffer. > * > * In order to facilitate/optimize cache flushing, a remote (target) > * node always receives a datatype that is sent, even if it already > * has a cache entry (i.e. it overwrites any existing cache data). > * This means that the origin node must only flush its own, local, cache > * when a datatype goes away, and if/when a new datatype uses the > * same handle then the target side will get a new copy and replace > * the old one. > */ > > /** \brief Number of Datatype Cache elements per allocation block */ > #define MPIDU_NUM_DTC_ENTRIES 7 > /** > * \brief Datatype Cache Element > */ > struct mpid_dtc_entry { > struct mpid_dtc_entry *next; /**< next used or next free */ > int lpid; /**< origin lpid, or target lpid | MSB */ > MPI_Datatype dt; /**< datatype handle on origin */ > int _pad; /**< pad to power of two size */ > mpid_dt_info dti; /**< extracted info from datatype */ > }; > /** \brief Padding for Datatype Cache Element resource block header */ > #define MPIDU_PAD_DTC_ENTRIES 0 > > /** \brief Queue Head for Datatype Cache */ > static struct mpid_qhead dtc = > MPIDU_INIT_QHEAD_DECL(MPIDU_NUM_DTC_ENTRIES, > sizeof(struct mpid_dtc_entry), MPIDU_PAD_DTC_ENTRIES); > > /* > * The following are used on the ranks passed to MPIDU_locate_dt() > * (et al.), specifically in the rank embedded in the element used to > * create, and search for, elements in the datatype cache. > */ > /** \brief OR'ed with rank in datatype cache in DT receives */ > #define MPIDU_ORIGIN_FLAG 0 > /** \brief OR'ed with rank in datatype cache in DT sends */ > #define MPIDU_TARGET_FLAG INT_MSB > > /** \brief test whether a datatype cache rank is target (origin-side entry) */ > #define MPIDU_IS_TARGET(r) (((r) & MPIDU_TARGET_FLAG) == MPIDU_TARGET_FLAG) > > /** \brief extract a datatype cache rank realm (TARGET or ORIGIN) */ > #define MPIDU_DT_REALM(r) ((r) & INT_MSB) > > /** \brief extract a datatype cache rank */ > #define MPIDU_DT_LPID(r) ((r) & ~INT_MSB) > > /** > * \brief Callback function to match datatype cache entry > * > * 'v1' is a struct mpid_dtc_entry with lpid and dt filled in with > * desired origin lpid and foreign datatype handle. > * 'v2' is the (currrent) struct mpid_dtc_entry being examined as > * a potential match. > * 'v3' optional pointer to element pointer, which will be filled > * with the element that contains the already-built datatype > * map and iovec, if it exists. This element is the one that > * has the local node's lpid. > * > * \param[in] v1 Desired datatype cache pseudo-element > * \param[in] v2 Datatype cache element to compare with 'v1' > * \param[in] v3 Pointer to Datatype cache element pointer > * where same datatype but different target > * will be saved, if v3 not NULL > * \return boolean indicating if 'v2' does not matche 'v1'. > * > * \ref dtcache_design > */ > static int mpid_match_dt(void *v1, void *v2, void *v3) { > struct mpid_dtc_entry *w1 = (struct mpid_dtc_entry *)v1; > struct mpid_dtc_entry *w2 = (struct mpid_dtc_entry *)v2; > > if (w1->dt != w2->dt) { > /* couldn't possibly match */ > return 1; > } > if (w1->lpid == w2->lpid) { > /* exact match */ > return 0; > } > if (v3 && MPIDU_DT_LPID(w2->lpid) == mpid_my_lpid) { > *((struct mpid_dtc_entry **)v3) = w2; > } > return 1; > } > > /** > * \brief Locate a cached foreign datatype. > * > * Internal use only - within datatype cache routines. > * Locate a foreign (remote, origin) datatype cache object in > * local cache. Returns pointer to datatype cache object. > * Uses origin lpid and (foreign) datatype to match. > * Flag/pointer 'new' indicates whether the object must not already exist. > * If 'new' is not NULL and object exists, sets *new to "0"; or if does > * not exist then create new object and set *new to "1". > * If 'new' is NULL and object does not exist, returns NULL. > * > * \param[in] lpid Rank of origin (locker) > * \param[in] dt Datatype handle to search for > * \param[in] new Pointer to boolean for flag indicating > * new element was created. If this is not NULL, > * then a new element will be created if none exists. > * \param[in] src Pointer to datatype cache element pointer > * used to save "closest match" element. > * \return If 'new' is false, returns pointer to > * datatype cache element found, or NULL if none found. > * In the case of 'new' being true, returns NULL if > * datatype already exists, or a pointer to a newly-created > * cache element otherwise. > * > * \ref dtcache_design > */ > static struct mpid_dtc_entry *MPIDU_locate_dt(int lpid, > MPI_Datatype dt, int *new, > struct mpid_dtc_entry **src) { > struct mpid_dtc_entry el, *ep; > > el.lpid = lpid; > el.dt = dt; > ep = MPIDU_find_element(&dtc, mpid_match_dt, src, &el, NULL); > if (new) { > if (ep == NULL) { > /* el was untouched by (failed) MPIDU_find_element() */ > memset(&el.dti, 0, sizeof(el.dti)); > ep = MPIDU_add_element(&dtc, &el); > *new = 1; > } else { > *new = 0; > } > } > return ep; > } > > /** > * \brief Callback function to match datatype cache entry for all lpids > * > * 'v1' is a struct mpid_dtc_entry with dt filled in with > * desired origin foreign datatype handle. > * 'v2' is the (currrent) struct mpid_dtc_entry being examined as > * a potential match. > * > * \param[in] v1 Desired datatype cache pseudo-element > * \param[in] v2 Datatype cache element to compare with 'v1' > * \param[in] v3 Not used. > * \return boolean indicating if 'v2' does not match 'v1', match > * on origin-side cache entry with same handle. > * > * \ref dtcache_design > */ > static int mpid_flush_dt(void *v1, void *v2, void *v3) { > struct mpid_dtc_entry *w1 = (struct mpid_dtc_entry *)v1; > struct mpid_dtc_entry *w2 = (struct mpid_dtc_entry *)v2; > > return (!MPIDU_IS_TARGET(w2->lpid) || w1->dt != w2->dt); > } > > /** > * \brief Function to remove all datatype cache entries for specific datatype > * > * Should be called whenever a datatype is freed/destroyed. Alternatively, > * could be called whenever a datatype is detected as having changed > * (i.e. handle gets re-used). > * > * \param[in] dtp MPID_Datatype object to be flushed > * \return number of entries flushed > */ > static int MPIDU_flush_dt(MPID_Datatype *dtp) { > struct mpid_dtc_entry el, *ep; > struct mpid_element *pp = NULL; > int n = 0; > > el.dt = dtp->handle; > while ((ep = MPIDU_find_element(&dtc, mpid_flush_dt, NULL, &el, &pp)) != NULL) { > if (MPIDU_DT_LPID(ep->lpid) == mpid_my_lpid) { > if (ep->dti.map) > MPIDU_FREE(ep->dti.map, mpi_errno, "MPIDU_flush_dt"); > if (ep->dti.dtp && !ep->dti.dtp->handle) > MPIDU_FREE(ep->dti.dtp, mpi_errno, "MPIDU_flush_dt"); > } > MPIDU_free_element(&dtc, ep, pp); > ++n; > } > return n; > } > > void MPIDU_dtc_free(MPID_Datatype *dtp) { > (void)MPIDU_flush_dt(dtp); > } > > #ifdef NOT_USED > /** > * \brief Get Datatype info for a foreign datatype > * > * Lookup a foreign (remote, origin) datatype in local cache. > * Uses origin lpid and (foreign) datatype. > * > * \param[in] lpid Rank of origin > * \param[in] fdt Foreign (origin) datatype handle to search for > * \param[out] dti Pointer to datatype info struct > * \return 0 if locally cached datatype found, > * or 1 if not found. > * > * \ref dtcache_design > */ > static int MPIDU_lookup_dt(int lpid, MPI_Datatype fdt, mpid_dt_info *dti) { > struct mpid_dtc_entry *dtc; > > if (lpid == mpid_my_lpid) { /* origin == target, was cached as "target" */ > lpid |= MPIDU_TARGET_FLAG; > } else { > lpid |= MPIDU_ORIGIN_FLAG; > } > dtc = MPIDU_locate_dt(lpid, fdt, NULL, NULL); > if (dtc != NULL && dtc->dti.map != NULL) { > if (dti) { > *dti = dtc->dti; > } > return 0; > } else { > return 1; > } > } > #endif /* NOT_USED */ > > /** > * \brief Prepare to receive a foreign datatype (step 1 - map). > * > * Called when MPID_MSGTYPE_DT_MAP (first datatype packet) received. > * Returns NULL if this datatype is already in the cache. > * Since the origin should be mirroring our cache status, > * we would expect to never see this case here. > * Must be the first of sequence: > * - MPID_MSGTYPE_DT_MAP > * - MPID_MSGTYPE_DT_IOV > * - MPID_MSGTYPE_ACC (_PUT, _GET) > * Although, the cache operation is not dependant on any subsequent > * RMA operations - i.e. the caching may be done for its own sake. > * > * Allocates storage for the map and updates cache element. > * > * mpid_info_w0 = MPID_MSGTYPE_MAP > * mpid_info_w1 = map size, bytes > * mpid_info_w2 = origin lpid > * mpid_info_w3 = foreign datatype handle > * mpid_info_w4 = datatype extent > * mpid_info_w5 = datatype element type > * mpid_info_w6 = datatype element size > * mpid_info_w7 = (not used) > * > * \param[in] mi MPIDU_Onesided_info_t containing data > * \return pointer to buffer to receive foreign datatype map > * structure, or NULL if datatype is already cached. > * > * \ref dtcache_design > */ > char *MPID_Prepare_rem_dt(MPIDU_Onesided_info_t *mi) { > struct mpid_dtc_entry *dtc; > int new = 0; > > dtc = MPIDU_locate_dt(mi->mpid_info_w2 | MPIDU_ORIGIN_FLAG, > (MPI_Datatype)mi->mpid_info_w3, &new, NULL); > if (!new) { > /* if origin is re-sending, they must know what they're doing. */ > if (dtc->dti.map) MPIDU_FREE(dtc->dti.map, mpi_errno, "MPID_Prepare_rem_dt"); > } > if (!dtc->dti.dtp) { > dtc->dti.dtp = MPIDU_MALLOC(dtc->dti.dtp, MPID_Datatype, sizeof(MPID_Datatype), mpi_errno, "MPID_Prepare_rem_dt"); > MPID_assert(dtc->dti.dtp != NULL); > } > /* caution! not a real datatype object! */ > dtc->dti.dtp->handle = 0; > dtc->dti.dtp->extent = mi->mpid_info_w4; > dtc->dti.dtp->eltype = mi->mpid_info_w5; > dtc->dti.dtp->element_size = mi->mpid_info_w6; > dtc->dti.map_len = 0; > MPIDU_MALLOC(dtc->dti.map, MPID_Type_map, mi->mpid_info_w1 * sizeof(*dtc->dti.map), mpi_errno, "MPID_Prepare_rem_dt"); > MPID_assert(dtc->dti.map != NULL); > #ifdef NOT_USED > dtc->dti.iov = NULL; > #endif /* NOT_USED */ > return (char *)dtc->dti.map; > } > > #ifdef NOT_USED > /** > * \brief Prepare to update foreign datatype (step 2 - iov). > * > * Called when MPID_MSGTYPE_DT_IOV (second datatype packet) received. > * Returns NULL if this datatype is already in the cache. > * Must be the second of sequence: > * - MPID_MSGTYPE_DT_MAP > * - MPID_MSGTYPE_DT_IOV > * - MPID_MSGTYPE_ACC (_PUT, _GET) > * > * Allocates storage for the iov and updates cache element. > * > * \param[in] lpid Rank of origin > * \param[in] fdt Foreign (origin) datatype handle to search for > * \param[in] dlz iov size (number of elements) > * \return pointer to buffer to receive foreign datatype iov > * structure, or NULL if datatype is already cached. > * > * \ref dtcache_design > */ > static char *mpid_update_rem_dt(int lpid, MPI_Datatype fdt, int dlz) { > struct mpid_dtc_entry *dtc; > > dtc = MPIDU_locate_dt(lpid | MPIDU_ORIGIN_FLAG, fdt, NULL, NULL); > MPID_assert_debug(dtc != NULL); > MPID_assert_debug(dtc->dti.iov == NULL); /* must follow MPID_MSGTYPE_DT_MAP */ > dtc->dti.iov_len = 0; > MPIDU_MALLOC(dtc->dti.iov, DLOOP_VECTOR, dlz * sizeof(*dtc->dti.iov), lpid, "mpid_update_rem_dt"); > MPID_assert(dtc->dti.iov != NULL); > return (char *)dtc->dti.iov; > } > #endif /* NOT_USED */ > > /** > * \brief completion for datatype cache messages (map and iov) > * > * To use this callback, the msginfo (DCQuad) must > * be filled as follows: > * > * - \e w0 - extent size > * - \e w1 - number of elements in map or iov > * - \e w2 - origin rank > * - \e w3 - datatype handle on origin > * > * \param[in] xt Pointer to xtra msginfo saved from original message > * \return nothing > * > */ > void MPID_Recvdone1_rem_dt(const DCQuad *xt) { > struct mpid_dtc_entry *dtc; > > dtc = MPIDU_locate_dt(xt->w2 | MPIDU_ORIGIN_FLAG, xt->w3, NULL, NULL); > MPID_assert_debug(dtc != NULL); > dtc->dti.map_len = xt->w1; > } > > #ifdef NOT_USED > /** > * \brief completion for datatype cache messages (map and iov) > * > * To use this callback, the msginfo (DCQuad) must > * be filled as follows: > * > * - \e w0 - MPID_MSGTYPE_DT_IOV > * - \e w1 - number of elements in map or iov > * - \e w2 - origin rank > * - \e w3 - datatype handle on origin > * > * \param[in] xt Pointer to xtra msginfo saved from original message > * \return nothing > * > */ > static void mpid_recvdone2_rem_dt(const DCQuad *xt) { > struct mpid_dtc_entry *dtc; > > dtc = MPIDU_locate_dt(xt->w2 | MPIDU_ORIGIN_FLAG, xt->w3, NULL, NULL); > MPID_assert_debug(dtc != NULL); > dtc->dti.iov_len = xt->w1; > } > #endif /* NOT_USED */ > > /** > * \brief Checks whether a local datatype has already been cached > * at the target node. > * > * Determine whether a local datatype has already been sent to > * this target (and thus is cached over there). > * Returns bool TRUE if datatype is (should be) in lpid's cache. > * > * Should only be called on the origin. > * > * \param[in] lpid lpid of target > * \param[in] dt Local datatype handle to search for > * \param[out] dti Pointer to datatype info struct > * \return Boolean TRUE if the datatype has already been cached. > * > * \ref dtcache_design > */ > int MPIDU_check_dt(int lpid, MPI_Datatype dt, mpid_dt_info *dti) { > struct mpid_dtc_entry *dtc, *cln = NULL; > int new = 0; > > dtc = MPIDU_locate_dt(lpid | MPIDU_TARGET_FLAG, dt, &new, &cln); > if (new) { > if (cln) { > /* > * same local datatype, different target, > * copy what we already have cached. > */ > dtc->dti = cln->dti; > } else { > /* > * first time using this datatype - create map/iov. > */ > make_dt_map_vec(dt, &dtc->dti); > #ifdef NOT_USED > MPID_assert_debug(dtc->dti.iov != NULL); > #endif /* NOT_USED */ > MPID_assert_debug(dtc->dti.map != NULL); > } > } > if (dti) { > *dti = dtc->dti; > } > /* we never send datatype */ > return 1; > return (!new); > } > > /* > * * * * * Request object (DCMF_Request_t) cache * * * * * > * > * because the request object is larger than a cache line, > * no attempt is made to keep objects cache-aligned, for example > * by padding the header to be the same size as the element or > * padding the element to a cache-line size. > * > * The "piggy-back" data is declared as DCQuad for no special > * reason - it was simply a convenient type that contained > * adequate space. This component is not used directly as > * msginfo in any message layer calls. > * > */ > > /** > * \page rqcache_design Request Object Cache Design > * > * The request cache element consists of a \e DCMF_Request_t > * and a single \e DCQuad that may be used to save context > * between the routine that allocated the request object and the > * callback that frees it. > * > * When a request is allocated, the only value returned is > * a pointer to the \e DCMF_Request_t field of the cache element. > * When a request is freed, the cache must be searched for > * a matching element, which is then moved to the free list. > * Before the element is moved to the free list, the \e DCQuad > * must be copied into a caller-supplied buffer or it will be lost. > * > * Callbacks that involve a request cache element will call > * \e MPIDU_free_req with a \e DCQuad buffer to receive the context > * info, if used. Then the context info is examined and action > * taken accordingly. Common use for the contaxt info is to > * free a buffer involved in a send operation and/or decrement > * a counter to indicate completion. > */ > > /** \brief Number of Request Cache elements per allocation block */ > #define MPIDU_NUM_RQC_ENTRIES 8 > /** > * \brief DCMF Request Cache Element > * > * \ref rqcache_design > */ > struct mpid_rqc_entry { > struct mpid_rqc_entry *next; /**< next used or next free */ > int _pad[3]; /**< must 16-byte align DCMF_Request_t */ > DCQuad bgq; /**< generic piggy-back. > * Not directly used in communications. */ > MPIDU_Onesided_info_t info; /**< MPID1S info */ > DCMF_Request_t req; /**< DCMF Request object */ > }; > /** \brief Padding for Request Cache Element resource block header */ > #define MPIDU_PAD_RQC_ENTRIES 0 > > /** \brief Queue Head for DCMF Request Object Cache */ > static struct mpid_qhead rqc = > MPIDU_INIT_QHEAD_DECL(MPIDU_NUM_RQC_ENTRIES, > sizeof(struct mpid_rqc_entry), MPIDU_PAD_RQC_ENTRIES); > > /** > * \brief Test if a request object is represented by the given element. > * > * \param[in] v1 Pointer to DCMF request object in question > * \param[in] v2 Pointer to request cache element to test > * \param[in] v3 not used > * \return 1 if NOT a matching request > * > * \ref rqcache_design > */ > static int mpid_match_rq(void *v1, void *v2, void *v3) { > DCMF_Request_t *w1 = (DCMF_Request_t *)v1; > struct mpid_rqc_entry *w2 = (struct mpid_rqc_entry *)v2; > > return (w1 != &w2->req); > } > > /** > * \brief Get a new request object from the resource queue. > * > * If 'bgq' is not NULL, copy data into request cache element, > * otherwise zero the field. > * Returns pointer to the request component of the cache element. > * > * \param[in] bgq Optional pointer to additional info to save > * \param[out] info Optional pointer to private msg info to use > * \return Pointer to DCMF request object > * > * \ref rqcache_design > */ > DCMF_Request_t *MPIDU_get_req(const DCQuad *bgq, > MPIDU_Onesided_info_t **info) { > struct mpid_rqc_entry *rqe; > > rqe = MPIDU_get_element(&rqc); > MPID_assert_debug(rqe != NULL); > // This assert is not relavent for non-BG and not needed for BG. > // MPID_assert_debug((((unsigned)&rqe->req) & 0x0f) == 0); > if (bgq) { > rqe->bgq = *bgq; > } else { > memset(&rqe->bgq, 0, sizeof(rqe->bgq)); > } > if (info) { > *info = &rqe->info; > } > return &rqe->req; > } > > /** > * \brief Release a DCMF request object and retrieve info > * > * Locate the request object in the request cache and free it. > * If 'bgq' is not NULL, copy piggy-back data into 'bgp'. > * Assumes request object was returned by a call to MPIDU_get_req(). > * > * \param[in] req Pointer to DCMF request object being released > * \param[out] bgq Optional pointer to receive saved additional info > * \return nothing > * > * \ref rqcache_design > */ > void MPIDU_free_req(DCMF_Request_t *req, DCQuad *bgq) { > struct mpid_rqc_entry *rqe; > struct mpid_element *pp = NULL; > > rqe = (struct mpid_rqc_entry *)MPIDU_find_element(&rqc, > mpid_match_rq, NULL, req, &pp); > MPID_assert_debug(rqe != NULL); > if (bgq) { > *bgq = rqe->bgq; > } > MPIDU_free_element(&rqc, rqe, pp); > } > > /* > * * * * * * Callbacks used on request cache objects * * * * * > */ > > /** > * \brief Generic request cache done callback with counter decr > * > * Callback for decrementing a "done" or pending count. > * > * To use this callback, the "xtra" info (DCQuad) must > * be filled as follows: > * > * - \e w0 - (int *) pending counter > * - \e w1 - ignored > * - \e w2 - ignored > * - \e w3 - ignored > * > * \param[in] v Pointer to DCMF request object > * \return nothing > * > * \ref rqcache_design > */ > void done_rqc_cb(void *v) { > volatile unsigned *pending; > DCQuad xtra; > > MPIDU_free_req((DCMF_Request_t *)v, &xtra); > pending = (volatile unsigned *)xtra.w0; > if (pending) { > --(*pending); > } > } > > #ifdef NOT_USED > /** > * \brief Generic request cache done callback with counter decr > * and 2-buffer freeing. > * > * Callback for decrementing a "done" or pending count and > * freeing malloc() memory, up to two pointers. > * > * To use this callback, the "xtra" info (DCQuad) must > * be filled as follows: > * > * - \e w0 - (int *) pending counter > * - \e w1 - ignored > * - \e w2 - (void *) allocated memory if not NULL > * - \e w3 - (void *) allocated memory if not NULL > * > * \param[in] v Pointer to DCMF request object > * \return nothing > * > * \ref rqcache_design > */ > static void done_free_rqc_cb(void *v) { > volatile unsigned *pending; > DCQuad xtra; > > MPIDU_free_req((DCMF_Request_t *)v, &xtra); > pending = (volatile unsigned *)xtra.w0; > if (pending) { > --(*pending); > } > if (xtra.w2) { MPIDU_FREE(xtra.w2, e, "xtra.w2"); } > if (xtra.w3) { MPIDU_FREE(xtra.w3, e, "xtra.w3"); } > } > #endif /* NOT_USED */ > > /** > * \brief request cache done callback for Get, with counter decr, > * ref count, buffer freeing and dt release when ref count reaches zero. > * Also uses dt to unpack results into application buffer. > * > * Callback for decrementing a "done" or pending count and > * freeing malloc() memory, up to two pointers, when ref count goes 0. > * > * To use this callback, the "xtra" info (DCQuad) must > * be filled as follows: > * > * - \e w0 - (int *) pending counter > * - \e w1 - (int *) get struct > * - \e w2 - (void *) allocated memory if not NULL > * - \e w3 - (void *) allocated memory if not NULL > * > * \param[in] v Pointer to DCMF request object > * \return nothing > * > * \ref rqcache_design > */ > void done_getfree_rqc_cb(void *v) { > volatile unsigned *pending; > volatile struct mpid_get_cb_data *get; > DCQuad xtra; > > MPIDU_free_req((DCMF_Request_t *)v, &xtra); > pending = (volatile unsigned *)xtra.w0; > get = (volatile struct mpid_get_cb_data *)xtra.w1; > if (pending) { > --(*pending); > } > MPID_assert_debug(get != NULL); > if (--get->ref == 0) { > MPID_assert_debug(get->dtp != NULL); > MPID_Segment segment; > DLOOP_Offset last; > > int mpi_errno = MPID_Segment_init(get->addr, > get->count, > get->dtp->handle, &segment, 0); > MPID_assert_debug(mpi_errno == MPI_SUCCESS); > last = get->len; > MPID_Segment_unpack(&segment, 0, &last, get->buf); > MPID_assert_debug(last == get->len); > MPID_Datatype_release(get->dtp); > if (xtra.w2) { MPIDU_FREE(xtra.w2, e, "xtra.w2"); } > if (xtra.w3) { MPIDU_FREE(xtra.w3, e, "xtra.w3"); } > } > } > > > /** > * \brief Generic request cache done callback with counter decr, > * ref count, and 2-buffer freeing when ref count reaches zero. > * > * Callback for decrementing a "done" or pending count and > * freeing malloc() memory, up to two pointers, when ref count goes 0. > * > * To use this callback, the "xtra" info (DCQuad) must > * be filled as follows: > * > * - \e w0 - (int *) pending counter > * - \e w1 - (int *) reference counter > * - \e w2 - (void *) allocated memory if not NULL > * - \e w3 - (void *) datatype to release if not NULL > * > * \param[in] v Pointer to DCMF request object > * \return nothing > * > * \ref rqcache_design > */ > void done_reffree_rqc_cb(void *v) { > volatile unsigned *pending, *ref; > DCQuad xtra; > > MPIDU_free_req((DCMF_Request_t *)v, &xtra); > pending = (volatile unsigned *)xtra.w0; > ref = (volatile unsigned *)xtra.w1; > if (pending) { > --(*pending); > } > if (ref == NULL || --(*ref) == 0) { > if (xtra.w2) { MPIDU_FREE(xtra.w2, e, "xtra.w2"); } > if (xtra.w3) { MPIDU_FREE(xtra.w3, e, "xtra.w3"); } > } > } > > #ifdef NOT_USED > /** > * \brief Callback for freeing malloc() memory, up to two pointers. > * > * To use this callback, the "xtra" info (DCQuad) must > * be filled as follows: > * > * - \e w0 - (void *) allocated memory if not NULL > * - \e w1 - (void *) allocated memory if not NULL > * - \e w2 - ignored > * - \e w3 - ignored > * > * \param[in] v Pointer to DCMF request object > * \return nothing > * > * \ref rqcache_design > */ > static void free_rqc_cb(void *v) { > DCQuad xtra; > > MPIDU_free_req((DCMF_Request_t *)v, &xtra); > if (xtra.w0) { MPIDU_FREE(xtra.w0, e, "xtra.w0"); } > if (xtra.w1) { MPIDU_FREE(xtra.w1, e, "xtra.w1"); } > } > #endif /* NOT_USED */ > > /** > * \brief Generic request cache callback for RMA op completion > * > * Callback for incrementing window RMA recvs count. > * Used only by Put and Accumulate (not used by Get). > * > * Only used for a "long message" - i.e. multi-packet - PUT. > * > * To use this callback, the "xtra" info (DCQuad) must > * be filled as follows: > * > * - \e w0 - ignored > * - \e w1 - window handle > * - \e w2 - origin rank > * - \e w3 - origin lpid > * > * \param[in] v Pointer to DCMF request object > * \return nothing > * > * \ref rqcache_design > */ > void rma_rqc_cb(void *v) { > MPID_Win *win; > DCQuad xtra; > > MPIDU_free_req((DCMF_Request_t *)v, &xtra); > MPID_Win_get_ptr((MPI_Win)xtra.w1, win); > MPID_assert_debug(win != NULL); > rma_recvs_cb(win, xtra.w2, xtra.w3); > } > > /** > * \brief Generic callback for request cache > * > * Callback for simply (only) freeing the request cache object. > * > * To use this callback, the "xtra" info (DCQuad) must > * be filled as follows: > * > * - \e w0 - ignored > * - \e w1 - ignored > * - \e w2 - ignored > * - \e w3 - ignored > * > * \param[in] v Pointer to DCMF request object > * \return nothing > * > * \ref rqcache_design > */ > void none_rqc_cb(void *v) { > MPIDU_free_req((DCMF_Request_t *)v, NULL); > } > > #ifdef NOT_USED > /** > * \brief Generic send done callback > * > * Local send callback. > * > * Simple "done" callback, currently used only by lock/unlock. > * Assumes param is an int * and decrements it. > * > * \param[in] v Pointer to integer counter to decrement > * \return nothing > */ > static void done_cb(void *v) { > int *cp = (int *)v; > --(*cp); > } > #endif /* NOT_USED */ > > /** > * \brief receive callback for datatype cache messages (map and iov) > * > * \param[in] v Pointer to request object used for transfer > * \return nothing > */ > void dtc1_rqc_cb(void *v) { > DCQuad xtra; > > MPIDU_free_req((DCMF_Request_t *)v, &xtra); > MPID_Recvdone1_rem_dt((const DCQuad *)&xtra); > } > > #ifdef NOT_USED > /** > * \brief receive callback for datatype cache messages (map and iov) > * > * \param[in] v Pointer to request object used for transfer > * \return nothing > */ > static void dtc2_rqc_cb(void *v) { > DCQuad xtra; > > MPIDU_free_req((DCMF_Request_t *)v, &xtra); > mpid_recvdone2_rem_dt((const DCQuad *)&xtra); > } > #endif /* NOT_USED */ > > /* > * * * * * * * * * * * * * * * * * * * * * * > */ > > /** > * \brief Send (spray) a protocol message to a group of nodes. > * > * Send a protocol message to all members of a group (or the > * window-comm if no group). > * > * Currently, this routine will only be called once per group > * (i.e. once during an exposure or access epoch). If it ends > * up being called more than once, it might make sense to build > * a translation table between the group rank and the window > * communicator rank. Or if we can determine that the same > * group is being used in multiple, successive, epochs. In practice, > * it takes more work to build a translation table than to lookup > * ranks ad-hoc. > * > * \param[in] win Pointer to MPID_Win object > * \param[in] grp Optional pointer to MPID_Group object > * \param[in] type Type of message (MPID_MSGTYPE_*) > * \return MPI_SUCCESS or error returned from DCMF_Send. > * > * \ref msginfo_usage > */ > int MPIDU_proto_send(MPID_Win *win, MPID_Group *grp, int type) { > int lpid, x; > MPIDU_Onesided_ctl_t ctl; > int size, comm_size = 0, comm_rank; > int mpi_errno = MPI_SUCCESS; > MPID_VCR *vc; > DCMF_Consistency consistency = win->_dev.my_cstcy; > > /* > * \todo Confirm this: > * For inter-comms, we only talk to the remote nodes. For > * intra-comms there are no remote or local nodes. > * So, we always use win->_dev.comm_ptr->vcr (?) > * However, we have to choose remote_size, in the case of > * inter-comms, vs. local_size. This decision also > * affects MPIDU_world_rank_c(). > */ > size = MPIDU_comm_size(win); > vc = MPIDU_world_vcr(win); > MPID_assert_debug(vc != NULL && size > 0); > if (grp) { > comm_size = size; > size = grp->size; > } > /** \todo is it OK to lower consistency here? */ > consistency = DCMF_RELAXED_CONSISTENCY; > > ctl.mpid_ctl_w0 = type; > ctl.mpid_ctl_w2 = win->_dev.comm_ptr->rank; > for (x = 0; x < size; ++x) { > if (grp) { > int z; > > lpid = grp->lrank_to_lpid[x].lpid; > /* convert group rank to comm rank */ > for (z = 0; z < comm_size && > lpid != vc[z]->lpid; ++z); > MPID_assert_debug(z < comm_size); > comm_rank = z; > } else { > lpid = vc[x]->lpid; > comm_rank = x; > } > ctl.mpid_ctl_w1 = win->_dev.coll_info[comm_rank].win_handle; > if (type == MPID_MSGTYPE_COMPLETE) { > ctl.mpid_ctl_w3 = win->_dev.coll_info[comm_rank].rma_sends; > win->_dev.coll_info[comm_rank].rma_sends = 0; > } > mpi_errno = DCMF_Control(&bg1s_ct_proto, consistency, lpid, &ctl.ctl); > if (mpi_errno) { break; } > } > return mpi_errno; > } > > /* > * * * * * * * * * * * * * * * * * * * * * * > */ > > /** > * \brief validate whether a lpid is in a given group > * > * Searches the group lpid list for a match. > * > * \param[in] lpid World rank of the node in question > * \param[in] grp Group to validate against > * \return TRUE is lpid is in group > */ > int MPIDU_valid_group_rank(int lpid, MPID_Group *grp) { > int size = grp->size; > int z; > > for (z = 0; z < size && > lpid != grp->lrank_to_lpid[z].lpid; ++z); > return (z < size); > } > > /* > * Remote (receiver) Callbacks. > */ > > /** > * \brief Receive callback for RMA protocol and operations messages > * > * "Small" message callback - the entire message is already here. > * Process it now and return. > * > * \param[in] _mi Pointer to msginfo > * \param[in] ct Number of DCQuad's in msginfo > * \param[in] or Rank of origin > * \param[in] sb Pointer to send buffer (data received) > * \param[in] sl Length (bytes) of data > * \return nothing > * > * \ref msginfo_usage > */ > void recv_sm_cb(void *cd, const DCQuad *_mi, unsigned ct, unsigned or, > const char *sb, const unsigned sl) { > MPID_Win *win; > char *rb; > MPIDU_Onesided_ctl_t *mc = (MPIDU_Onesided_ctl_t *)_mi; > MPIDU_Onesided_info_t *mi = (MPIDU_Onesided_info_t *)_mi; > > switch (_mi[0].w0) { > /* The following all use msginfo as DCMF_Control_t (DCQuad[1]) */ > case MPID_MSGTYPE_COMPLETE: > MPID_assert_debug(ct == 1); > MPID_assert_debug(sl == 0); > MPID_Win_get_ptr((MPI_Win)mc->mpid_ctl_w1, win); > MPID_assert_debug(win != NULL); > win->_dev.coll_info[win->_dev.comm_ptr->rank].rma_sends += mc->mpid_ctl_w3; > ++win->_dev.my_sync_done; > break; > case MPID_MSGTYPE_POST: > MPID_assert_debug(ct == 1); > MPID_assert_debug(sl == 0); > MPID_Win_get_ptr((MPI_Win)mc->mpid_ctl_w1, win); > MPID_assert_debug(win != NULL); > ++win->_dev.my_sync_begin; > break; > case MPID_MSGTYPE_LOCK: > MPID_assert_debug(ct == 1); > lock_cb(mc, or); > break; > case MPID_MSGTYPE_UNLOCK: > MPID_assert_debug(ct == 1); > unlk_cb(mc, or); > break; > case MPID_MSGTYPE_LOCKACK: > case MPID_MSGTYPE_UNLOCKACK: > MPID_assert_debug(ct == 1); > MPID_Win_get_ptr((MPI_Win)mc->mpid_ctl_w1, win); > MPID_assert_debug(win != NULL); > ++win->_dev.my_sync_done; > break; > > /* The following all use msginfo as DCQuad[2] */ > case MPID_MSGTYPE_PUT: > MPID_assert_debug(ct == 2); > MPID_assert_debug(sl != 0); > MPID_Win_get_ptr((MPI_Win)mi->mpid_info_w1, win); > MPID_assert_debug(win != NULL); > MPIDU_assert_PUTOK(win); > if (win->_dev.epoch_assert & MPI_MODE_NOPUT) { > /** \todo exact error handling */ > } > memcpy((char *)mi->mpid_info_w3, sb, sl); > rma_recvs_cb(win, mi->mpid_info_w2, or); > break; > case MPID_MSGTYPE_DT_MAP: > MPID_assert_debug(ct == 2); > rb = MPID_Prepare_rem_dt(mi); > if (rb) { > DCQuad xtra; > > xtra.w0 = mi->mpid_info_w0; > xtra.w1 = mi->mpid_info_w1; > xtra.w2 = mi->mpid_info_w2; > xtra.w3 = mi->mpid_info_w3; > memcpy(rb, sb, sl); > MPID_Recvdone1_rem_dt(&xtra); > } > break; > case MPID_MSGTYPE_DT_IOV: > #ifdef NOT_USED > MPID_assert_debug(ct == 2); > rb = mpid_update_rem_dt(mi->mpid_info_w2, mi->mpid_info_w3, mi->mpid_info_w1); > if (rb) { > memcpy(rb, sb, sl); > mpid_recvdone2_rem_dt(_mi); > } > break; > #endif /* NOT_USED */ > MPID_abort(); > case MPID_MSGTYPE_ACC: > MPID_assert_debug(ct == 2); > MPID_Win_get_ptr((MPI_Win)mi->mpid_info_w1, win); > MPID_assert_debug(win != NULL); > MPIDU_assert_PUTOK(win); > if (win->_dev.epoch_assert & MPI_MODE_NOPUT) { > /** \todo exact error handling */ > } > target_accumulate(mi, sb, or); > break; > > /* Not supported message types */ > case MPID_MSGTYPE_GET: /* GET can't generate these */ > MPID_abort(); > default: > /* > * Don't know what to do with this... we have some data > * (possibly) but don't have a target address to copy it > * to (or know what else to do with it). > */ > break; > } > } > > /** > * \brief Callback for DCMF_Control() messages > * > * Simple pass-through to recv_sm_cb() with zero-length data. > * > * \param[in] ctl Control message (one quad) > * \param[in] or Origin node lpid > * \return nothing > */ > void recv_ctl_cb(void *cd, const DCMF_Control_t *ctl, unsigned or) { > recv_sm_cb(cd, (const DCQuad *)ctl, 1, or, NULL, 0); > } > > /** > * \brief Receive callback for RMA operations messages > * > * "Message receive initiated" callback. > * This one should never get called for protocol messages. > * Setup buffers, get a request object, and return so receive can begin. > * In some cases (e.g. MPID_MSGTYPE_ACC) the processing is done in the > * receive completion callback, otherwise that callback just frees > * the request and cleans up (updates counters). > * > * \param[in] _mi Pointer to msginfo > * \param[in] ct Number of DCQuad's in msginfo > * \param[in] or Rank of origin > * \param[in] sl Length (bytes) of sent data > * \param[out] rl Length (bytes) of data to receive > * \param[out] rb receive buffer > * \param[out] cb callback to invoke after receive > * \return Pointer to DCMF request object to use for receive, > * or NULL to discard received data > * > * \ref msginfo_usage > */ > DCMF_Request_t *recv_cb(void *cd, const DCQuad *_mi, unsigned ct, > unsigned or, const unsigned sl, unsigned *rl, > char **rb, DCMF_Callback_t *cb) > { > DCMF_Request_t *req; > MPID_Win *win; > MPIDU_Onesided_info_t *mi = (MPIDU_Onesided_info_t *)_mi; > > switch (_mi[0].w0) { > /* The following all use msginfo as DCQuad[2] */ > case MPID_MSGTYPE_PUT: > MPID_assert_debug(ct == 2); > MPID_Win_get_ptr((MPI_Win)mi->mpid_info_w1, win); > MPID_assert_debug(win != NULL); > MPIDU_assert_PUTOK(win); > if (win->_dev.epoch_assert & MPI_MODE_NOPUT) { > /** \todo exact error handling */ > } > MPID_assert_debug(mi->mpid_info_w3 >= > (unsigned)win->base && > mi->mpid_info_w3 + sl <= > (unsigned)win->base + win->size); > *rl = sl; > *rb = (char *)mi->mpid_info_w3; > { DCQuad xtra; > xtra.w0 = mi->mpid_info_w3; > xtra.w1 = mi->mpid_info_w1; > xtra.w2 = mi->mpid_info_w2; > xtra.w3 = or; > req = MPIDU_get_req(&xtra, NULL); > } > cb->clientdata = req; > cb->function = rma_rqc_cb; > return req; > case MPID_MSGTYPE_DT_MAP: > MPID_assert_debug(ct == 2); > *rb = MPID_Prepare_rem_dt(mi); > if (!*rb) { > return NULL; > } > *rl = sl; > { DCQuad xtra; > xtra.w0 = mi->mpid_info_w0; > xtra.w1 = mi->mpid_info_w1; > xtra.w2 = mi->mpid_info_w2; > xtra.w3 = mi->mpid_info_w3; > req = MPIDU_get_req(&xtra, NULL); > } > cb->clientdata = req; > cb->function = dtc1_rqc_cb; > return req; > case MPID_MSGTYPE_DT_IOV: > #ifdef NOT_USED > MPID_assert_debug(ct == 2); > *rb = mpid_update_rem_dt(mi->mpid_info_w2, mi->mpid_info_w3, mi->mpid_info_w1); > if (!*rb) { > return NULL; > } > *rl = sl; > { DCQuad xtra; > xtra.w0 = mi->mpid_info_w0; > xtra.w1 = mi->mpid_info_w1; > xtra.w2 = mi->mpid_info_w2; > xtra.w3 = mi->mpid_info_w3; > req = MPIDU_get_req(&xtra, NULL); > } > cb->clientdata = req; > cb->function = dtc2_rqc_cb; > return req; > #endif /* NOT_USED */ > MPID_abort(); > case MPID_MSGTYPE_ACC: > MPID_assert_debug(ct == 2); > { /* block */ > MPIDU_Onesided_info_t *info; > DCQuad xtra = {0}; > > MPID_Win_get_ptr((MPI_Win)mi->mpid_info_w1, win); > MPID_assert_debug(win != NULL); > MPIDU_assert_PUTOK(win); > if (win->_dev.epoch_assert & MPI_MODE_NOPUT) { > /** \todo exact error handling */ > } > /** \note These embedded DCQuads are not directly > * used in any communications. */ > MPIDU_MALLOC(info, MPIDU_Onesided_info_t, > sizeof(MPIDU_Onesided_info_t) + sl, e, "MPID_MSGTYPE_ACC"); > MPID_assert_debug(info != NULL); > *rb = (char *)(info + 1); > *rl = sl; > memcpy(info, mi, sizeof(MPIDU_Onesided_info_t)); > xtra.w2 = (unsigned)info; > xtra.w3 = or; > req = MPIDU_get_req(&xtra, NULL); > cb->clientdata = req; > cb->function = accum_cb; > return req; > } /* block */ > > /* The following all use msginfo as DCMF_Control_t (DCQuad[1]) */ > case MPID_MSGTYPE_POST: > case MPID_MSGTYPE_COMPLETE: > /* Win_post/Win_complete messages are always small. */ > case MPID_MSGTYPE_LOCK: > case MPID_MSGTYPE_UNLOCK: > case MPID_MSGTYPE_LOCKACK: > case MPID_MSGTYPE_UNLOCKACK: > MPID_abort(); > case MPID_MSGTYPE_GET: /* GET can't generate these */ > MPID_abort(); > default: > break; > } > return NULL; > } > > /* > * End of remote callbacks. > */ > > #ifdef NOT_USED > /** > * \brief Send local datatype to target node > * > * Routine to send target datatype to target node. > * These sends are handled by recv callbacks above... > * > * \param[in] dt datatype handle to send > * \param[in] o_lpid Origin lpid > * \param[in] t_lpid Target lpid > * \param[out] pending Pointer to send done counter > * \param[in,out] consistency Pointer for consistency used for sends (out) > * \return MPI_SUCCESS, or error returned by DCMF_Send. > * > * \ref msginfo_usage\n > * \ref dtcache_design > */ > int mpid_queue_datatype(MPI_Datatype dt, > int o_lpid, int t_lpid, volatile unsigned *pending, > DCMF_Consistency *consistency) { > MPIDU_Onesided_info_t *info; > DCQuad xtra = {0}; > DCMF_Callback_t cb_send; > DCMF_Request_t *reqp; > int mpi_errno = MPI_SUCCESS; > mpid_dt_info dti; > > if (MPIDU_check_dt(t_lpid, dt, &dti)) { > /* we've previously sent this datatype to that target */ > return mpi_errno; > } > /** \todo need to ensure we don't LOWER consistency... */ > *consistency = DCMF_WEAK_CONSISTENCY; > xtra.w0 = (unsigned)pending; > > reqp = MPIDU_get_req(&xtra, &info); > info->mpid_info_w0 = MPID_MSGTYPE_DT_MAP; > info->mpid_info_w1 = dti.map_len; > info->mpid_info_w2 = o_lpid; > info->mpid_info_w3 = dt; > info->mpid_info_w4 = dti.dtp->extent; > info->mpid_info_w5 = dti.dtp->eltype; > info->mpid_info_w6 = dti.dtp->element_size; > ++(*pending); > cb_send.function = done_rqc_cb; > cb_send.clientdata = reqp; > mpi_errno = DCMF_Send(&bg1s_sn_proto, reqp, cb_send, > *consistency, t_lpid, > dti.map_len * sizeof(*dti.map), (char *)dti.map, > info->info, 2); > if (mpi_errno) { return(mpi_errno); } > reqp = MPIDU_get_req(&xtra, &info); > info->mpid_info_w0 = MPID_MSGTYPE_DT_IOV; > info->mpid_info_w1 = dti.iov_len; > info->mpid_info_w2 = o_lpid; > info->mpid_info_w3 = dt; > info->mpid_info_w4 = dti.dtp->extent; > info->mpid_info_w5 = dti.dtp->eltype; > info->mpid_info_w6 = dti.dtp->element_size; > ++(*pending); > cb_send.function = done_rqc_cb; > cb_send.clientdata = reqp; > mpi_errno = DCMF_Send(&bg1s_sn_proto, reqp, cb_send, > *consistency, t_lpid, > dti.iov_len * sizeof(*dti.iov), (char *)dti.iov, > info->info, 2); > return mpi_errno; > } > #endif /* NOT_USED */ diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/onesided/mpid_win_create.c bgp-mpich2/src/mpid/dcmf/src/onesided/mpid_win_create.c 0a1,262 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file src/onesided/mpid_win_create.c > * \brief MPI-DCMF MPI_Win_create/free functionality > * > * Includes general onesided initialization (via first call to MPID_Win_create). > */ > > #include "mpid_onesided.h" > > /** > * \brief One-time initialization of control messages protocol > * > * \return nothing > */ > static void mpid_ctl_init(void) { > DCMF_Control_Configuration_t ctl_cfg = > { DCMF_DEFAULT_CONTROL_PROTOCOL, recv_ctl_cb, NULL}; > DCMF_Control_register(&bg1s_ct_proto, &ctl_cfg); > } > > /** > * \brief One-time initialization of locks > * > * \return nothing > */ > static void mpid_lock_init(void) { > } > > /** > * \brief One-time initialization of sends > * > * \return nothing > */ > static void mpid_send_init(void) { > DCMF_Send_Configuration_t send_cfg = > { DCMF_DEFAULT_SEND_PROTOCOL, recv_sm_cb, NULL, recv_cb, NULL }; > > DCMF_Send_register(&bg1s_sn_proto, &send_cfg); > } > > /** > * \brief One-time initialization of gets > * > * \return nothing > */ > static void mpid_get_init(void) { > DCMF_Get_Configuration_t get_cfg = > { DCMF_DEFAULT_GET_PROTOCOL }; > > DCMF_Get_register(&bg1s_gt_proto, &get_cfg); > } > > /** > * \brief User defined function to handle summing of rma_sends > * > * \param[in] v1 Source data > * \param[in] v2 Destination data > * \param[in] i1 number of elements > * \param[in] d1 datatype > * \return nothing > */ > static void sum_coll_info(void *v1, void *v2, int *i1, MPI_Datatype *d1) { > struct MPID_Win_coll_info *in = v1, *out = v2; > int len = *i1; > int x; > > MPID_assert_debug(*d1 == Coll_info_rma_dt); > for (x = 0; x < len; ++x) { > out->rma_sends += in->rma_sends; > ++out; > ++in; > } > } > > /** > * \brief One-time MPID one-sided initialization > * > * \return nothing > */ > static void mpid_init(void) { > mpid_lock_init(); > mpid_send_init(); > mpid_ctl_init(); > mpid_get_init(); > /* > * need typemap { (int,12), (int,28), ... } > * > * i.e. [0] => &(*win_ptr)->coll_info[0].rma_sends, > * [1] => &(*win_ptr)->coll_info[1].rma_sends, > * [2] => &(*win_ptr)->coll_info[2].rma_sends, > * ... > */ > MPI_Type_contiguous(4, MPI_INT, &Coll_info_rma_dt); > MPI_Type_commit(&Coll_info_rma_dt); > MPI_Op_create(sum_coll_info, 0, &Coll_info_rma_op); > } > > /// \cond NOT_REAL_CODE > #undef FUNCNAME > #define FUNCNAME MPID_Win_create > #undef FCNAME > #define FCNAME MPIU_QUOTE(FUNCNAME) > /// \endcond > /** > * \brief MPI-DCMF glue for MPI_WIN_CREATE function > * > * Create a window object. Allocates a MPID_Win object and initializes it, > * then allocates the collective info array, initalizes our entry, and > * performs an Allgather to distribute/collect the rest of the array entries. > * > * ON first call, initializes (registers) protocol objects for locking, > * get, and send operations to message layer. Also creates datatype to > * represent the rma_sends element of the collective info array, > * used later to synchronize epoch end events. > * > * \param[in] base Local window buffer > * \param[in] size Local window size > * \param[in] disp_unit Displacement unit size > * \param[in] info Window hints (not used) > * \param[in] comm_ptr Communicator > * \param[out] win_ptr Window > * \return MPI_SUCCESS, MPI_ERR_OTHER, or error returned from > * NMPI_Comm_dup or NMPI_Allgather. > */ > int MPID_Win_create(void *base, MPI_Aint size, int disp_unit, > MPID_Info *info, MPID_Comm *comm_ptr, > MPID_Win **win_ptr) > { > static int initial = 0; > MPID_Win *win; > int mpi_errno=MPI_SUCCESS, comm_size, rank; > > MPIU_THREADPRIV_DECL; > MPID_MPI_STATE_DECL(MPID_STATE_MPID_WIN_CREATE); > > MPID_MPI_FUNC_ENTER(MPID_STATE_MPID_WIN_CREATE); > > MPIU_UNREFERENCED_ARG(info); > MPIU_THREADPRIV_GET; > MPIR_Nest_incr(); > > comm_size = MPIDU_comm_size_c(comm_ptr); > rank = comm_ptr->rank; > > if (!initial++) { > MPID_assert_debug(sizeof(((MPIDU_Onesided_ctl_t *)0)->_c_u) <= > sizeof(((MPIDU_Onesided_ctl_t *)0)->ctl)); > mpid_init(); > mpid_my_lpid = MPIDU_world_rank_c(comm_ptr, rank); > //initial = 0; > } > > win = (MPID_Win *)MPIU_Handle_obj_alloc(&MPID_Win_mem); > MPIU_ERR_CHKANDJUMP(!win,mpi_errno,MPI_ERR_OTHER,"**nomem"); > memset((char *)win + sizeof(MPIU_Handle_head), 0, > sizeof(*win) - sizeof(MPIU_Handle_head)); > > win->base = base; > win->size = size; > win->disp_unit = disp_unit; > /* MPID_DEV_WIN_DECL ... */ > mpidu_init_lock(win); > win->_dev.epoch_type = MPID_EPOTYPE_NONE; > win->_dev.my_cstcy = DCMF_MATCH_CONSISTENCY; > > mpi_errno = NMPI_Comm_dup(comm_ptr->handle, &win->comm); > if (mpi_errno) { MPIU_ERR_POP(mpi_errno); } > MPID_assert_debug(win->comm != MPI_COMM_NULL); > > MPID_Comm_get_ptr(win->comm, win->_dev.comm_ptr); > MPID_assert_debug(win->_dev.comm_ptr != NULL); > > /* allocate memory for the base addresses, disp_units, and > completion counters of all processes */ > > MPIDU_MALLOC(win->_dev.coll_info, struct MPID_Win_coll_info, > comm_size * sizeof(struct MPID_Win_coll_info), > mpi_errno, "win->_dev.coll_info"); > /* FIXME: This needs to be fixed for heterogeneous systems */ > win->_dev.coll_info[rank].base_addr = base; > win->_dev.coll_info[rank].disp_unit = (MPI_Aint) disp_unit; > win->_dev.coll_info[rank].win_handle = (MPI_Aint) win->handle; > win->_dev.coll_info[rank].rma_sends = 0; /* Allgather zeros these */ > > mpi_errno = NMPI_Allgather(MPI_IN_PLACE, 0, MPI_DATATYPE_NULL, > win->_dev.coll_info, > sizeof(struct MPID_Win_coll_info), > MPI_BYTE, comm_ptr->handle); > if (mpi_errno) { MPIU_ERR_POP(mpi_errno); } > /* try to avoid a race where one node sends us a lock request > * before we're ready */ > mpi_errno = NMPI_Barrier(comm_ptr->handle); > if (mpi_errno) { MPIU_ERR_POP(mpi_errno); } > *win_ptr = win; > > fn_exit: > MPIR_Nest_decr(); > MPID_MPI_FUNC_EXIT(MPID_STATE_MPID_WIN_CREATE); > return mpi_errno; > /* --BEGIN ERROR HANDLING-- */ > fn_fail: > goto fn_exit; > /* --END ERROR HANDLING-- */ > } > > /// \cond NOT_REAL_CODE > #undef FUNCNAME > #define FUNCNAME MPID_Win_free > #undef FCNAME > #define FCNAME MPIU_QUOTE(FUNCNAME) > /// \endcond > /** > * \brief MPI-DCMF glue for MPI_WIN_FREE function > * > * Release all references and free memory associated with window. > * > * \param[in,out] win_ptr Window > * \return MPI_SUCCESS or error returned from NMPI_Barrier. > */ > int MPID_Win_free(MPID_Win **win_ptr) > { > int mpi_errno=MPI_SUCCESS; > MPID_Win *win = *win_ptr; > MPIU_THREADPRIV_DECL; > MPID_MPI_STATE_DECL(MPID_STATE_MPID_WIN_FREE); > > MPID_MPI_FUNC_ENTER(MPID_STATE_MPID_WIN_FREE); > MPIU_THREADPRIV_GET; > MPIR_Nest_incr(); > > MPID_assert(win->_dev.epoch_type == MPID_EPOTYPE_NONE); > > mpi_errno = NMPI_Barrier(win->_dev.comm_ptr->handle); > if (mpi_errno) { MPIU_ERR_POP(mpi_errno); } > /* > * previous while loop and barrier will not exit until all waiters have > * been granted the lock. > */ > NMPI_Comm_free(&win->comm); > MPIDU_FREE(win->_dev.coll_info, mpi_errno, "win->_dev.coll_info"); > mpidu_free_lock(win); > /** \todo check whether refcount needs to be decremented > * here as in group_free */ > MPIU_Handle_obj_free(&MPID_Win_mem, win); > *win_ptr = NULL; > fn_exit: > MPIR_Nest_decr(); > MPID_MPI_FUNC_EXIT(MPID_STATE_MPID_WIN_FREE); > return mpi_errno; > /* --BEGIN ERROR HANDLING-- */ > fn_fail: > goto fn_exit; > /* --END ERROR HANDLING-- */ > } diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/onesided/mpid_win_fence.c bgp-mpich2/src/mpid/dcmf/src/onesided/mpid_win_fence.c 0a1,173 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file src/onesided/mpid_win_fence.c > * \brief MPI-DCMF MPI_Win_fence functionality > */ > > #include "mpid_onesided.h" > > /** > * \page fence_design MPID_Win_fence Design > * > * A fence / RMA / fence sequence is as follows: > * > * The following assumes that all nodes are in-sync with respect to > * synchronization primitives. If not, nodes will fail their > * synchronization calls as appropriate. > * > * All nodes in window communicator call MPI_Win_fence > * > * \e ASSUMPTION: Each node's window is in state MPID_EPOTYPE_NONE. > * > * - A sanity-check is done to > * ensure that the window is in a valid state to enter a > * \e FENCE access/exposure epoch. These checks include testing that > * no other epoch is currently in affect. > * - If MPI_MODE_NOSUCCEED is asserted, fail with MPI_ERR_RMA_SYNC. > * - If the local window is currenty locked then wait for the > * lock to be released (calling advance in the loop). > * - Set epoch type to MPID_EPOTYPE_FENCE, epoch size to window > * communicator size, and save MPI_MODE_* assertions. > * - Call NMPI_Barrier on the window communicator to wait for all > * nodes to reach this point. > * > * One or more nodes invoke RMA operation(s) > * > * - See respective RMA operation calls for details > * > * All nodes in window communicator call MPI_Win_fence > * > * \e ASSUMPTION: Each node's window is in state MPID_EPOTYPE_FENCE. > * > * - A sanity-check is done to > * ensure that the window is in a valid state to end a > * \e FENCE access/exposure epoch. These checks include testing that > * a \e FENCE epoch is currently in affect. > * - If MPI_MODE_NOPRECEDE is asserted, fail with MPI_ERR_RMA_SYNC. > * - \e MPID_assert_debug that the local window is not locked. > * - Call NMPI_Allreduce on the window communicator to sum > * the \e rma_sends > * fields in the collective info array. This also waits for all > * nodes to reach this point. This operation provides each node with > * the total number of RMA operations that other nodes sent to it. > * - wait for the number of RMA operations received to equal the > * number of RMA operations that were sent to us, calling advance > * in the loop. > * - Reset epoch information in window to indicate the epoch has ended. > */ > /// \cond NOT_REAL_CODE > #undef FUNCNAME > #define FUNCNAME MPID_Win_fence > #undef FCNAME > #define FCNAME MPIU_QUOTE(FUNCNAME) > /// \endcond > /** > * \brief MPI-DCMF glue for MPI_WIN_FENCE function > * > * Begin or end an access/exposure epoch on nodes in the window communicator. > * If begin, > * - perform a Barrier until all other nodes pass through the MPI_Win_fence. > * If end: > * - perform an Allreduce on the rma_sends element of the collective info array. > * - while rma_sends (to us) > rma_recvs call advance. > * > * \param[in] assert Synchronization hints > * \param[in] win_ptr Window > * \return MPI_SUCCESS, MPI_ERR_RMA_SYNC, or error returned from > * NMPI_Allreduce or NMPI_Barrier. > * > * \ref fence_design > */ > int MPID_Win_fence(int assert, MPID_Win *win_ptr) > { > int mpi_errno = MPI_SUCCESS; > int rank = win_ptr->_dev.comm_ptr->rank; > MPIU_THREADPRIV_DECL; > MPID_MPI_STATE_DECL(MPID_STATE_MPID_WIN_FENCE); > > MPID_MPI_FUNC_ENTER(MPID_STATE_MPID_WIN_FENCE); > MPIU_THREADPRIV_GET; > MPIR_Nest_incr(); > > if (win_ptr->_dev.epoch_type == MPID_EPOTYPE_FENCE) { > if (assert & MPI_MODE_NOPRECEDE) { > /* --BEGIN ERROR HANDLING-- */ > MPIU_ERR_SETANDSTMT(mpi_errno, MPI_ERR_RMA_SYNC, > goto fn_fail, "**rmasync"); > /* --END ERROR HANDLING-- */ > } > /* ??? assert |= win_ptr->_dev.epoch_assert ??? */ > MPID_assert_debug(MPIDU_is_lock_free(win_ptr)); > mpi_errno = NMPI_Allreduce(MPI_IN_PLACE, > win_ptr->_dev.coll_info, > MPIDU_comm_size(win_ptr), > Coll_info_rma_dt, Coll_info_rma_op, > win_ptr->_dev.comm_ptr->handle); > if (mpi_errno) { > char buf[MPI_MAX_ERROR_STRING]; > int buf_len; > MPI_Error_string(mpi_errno, buf, &buf_len); > if (1) fprintf(stderr, "%d: MPID_Win_fence failed NMPI_Allreduce: %s\n", mpid_my_lpid, buf); > MPIU_ERR_POP(mpi_errno); } > MPIDU_Progress_spin(win_ptr->_dev.my_get_pends > 0 || > win_ptr->_dev.my_rma_recvs < > win_ptr->_dev.coll_info[rank].rma_sends); > if ((win_ptr->_dev.epoch_assert & MPI_MODE_NOPUT) && > win_ptr->_dev.my_rma_recvs > 0) { > /* TBD: handled earlier? */ > } > win_ptr->_dev.epoch_type = MPID_EPOTYPE_NONE; > win_ptr->_dev.epoch_size = 0; > win_ptr->_dev.epoch_assert = 0; > win_ptr->_dev.epoch_rma_ok = 0; > win_ptr->_dev.my_sync_done = 0; > epoch_end_cb(win_ptr); > > } else if (win_ptr->_dev.epoch_type == MPID_EPOTYPE_NONE) { > if (assert & MPI_MODE_NOSUCCEED) { > /* --BEGIN ERROR HANDLING-- */ > MPIU_ERR_SETANDSTMT(mpi_errno, MPI_ERR_RMA_SYNC, > goto fn_fail, "**rmasync"); > /* --END ERROR HANDLING-- */ > } > MPIDU_Spin_lock_free(win_ptr); > win_ptr->_dev.epoch_type = MPID_EPOTYPE_FENCE; > win_ptr->_dev.epoch_size = MPIDU_comm_size(win_ptr); > win_ptr->_dev.epoch_assert = assert; > win_ptr->_dev.epoch_rma_ok = 1; > win_ptr->_dev.my_rma_recvs = 0; > win_ptr->_dev.my_sync_done = 0; // not used > win_ptr->_dev.my_sync_begin = 0; // not used > /* wait for everyone else to reach this point */ > mpi_errno = NMPI_Barrier(win_ptr->_dev.comm_ptr->handle); > if (mpi_errno) { MPIU_ERR_POP(mpi_errno); } > if (win_ptr->_dev.epoch_assert & MPI_MODE_NOSTORE) { > /* TBD: anything to optimize? */ > } > if (win_ptr->_dev.epoch_assert & MPI_MODE_NOPUT) { > /* handled later */ > } > > } else { > /* --BEGIN ERROR HANDLING-- */ > MPIU_ERR_SETANDSTMT(mpi_errno, MPI_ERR_RMA_SYNC, > goto fn_fail, "**rmasync"); > /* --END ERROR HANDLING-- */ > } > > fn_exit: > MPIR_Nest_decr(); > MPID_MPI_FUNC_EXIT(MPID_STATE_MPID_WIN_FENCE); > return mpi_errno; > /* --BEGIN ERROR HANDLING-- */ > fn_fail: > goto fn_exit; > /* --END ERROR HANDLING-- */ > } diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/onesided/mpid_win_lock.c bgp-mpich2/src/mpid/dcmf/src/onesided/mpid_win_lock.c 0a1,923 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file src/onesided/mpid_win_lock.c > * \brief MPI-DCMF MPI_Win_lock/unlock functionality > */ > > #include "mpid_onesided.h" > > /** > * \brief Progress (advance) spin to acquire lock locally > * > * Adds a local waiter to the lock wait queue, to ensure that > * we will eventually get a chance. This special waiter (ack[0].w0 == 0) > * will result in the \e my_sync_done flag getting set, breaking us > * out of the loop. At this point, we will have acquired the lock > * (possibly shared with others). > * > * Called from MPID_Win_lock when the \e dest rank is ourself (local). > * > * \param[in] win Pointer to MPID_Win object > * \param[in] rank Our rank (convenience) > * \param[in] type Lock type > * \return nothing > */ > #define MPIDU_Spin_lock_acquire(win, rank, type) { \ > if (local_lock(win, rank, type) == 0) { \ > (win)->_dev.my_sync_done = 0; \ > MPIDU_add_waiter(win, rank, type, NULL); \ > MPIDU_Progress_spin((win)->_dev.my_sync_done == 0);\ > } \ > } > > /* > * * * * * Win Locks and Lock wait queue * * * * * > */ > > /** > * \page lock_wait_design Lock Wait Queue Design > * > * When a lock cannot be immediately granted, the caller > * specifics (rank, lock request type, DCMF ack info) is added > * to the bottom of the lock wait queue. A lock may not be > * granted for the following reasons: > * > * - Window is involved in some other type of epoch. > * - Lock is in an incompatible state with request type. > * - Lock and request are shared, but the lock wait queue > * is not empty. This request must be queued to avoid > * starvation of the waiter(s). > * > * When ever a lock is released, the top of the lock wait queue > * is examined to see if the waiter is requesting a lock type > * that is compatible with the current lock status. > * > * - Lock is free: any waiter can be granted > * - Lock is shared: only a share waiter can be granted > * - Lock is exclusive: no waiter can be granted > * - Waiter is "dummy" requesting lock type 0, in which case > * subsequent waiters are left waiting so that another type > * of epoch can begin. > * > * The third case cannot happen since an unlock cannot result > * in the lock (still) being locked exclusive. > * > * The second case would probably only find a waiter of type > * exclusive, since any shared requests that came along would > * have been granted. > * > * \ref unlk_wait_design > */ > > /** > * \brief Shortcut for accessing the lock waiter queue > * object in the window structure. > */ > #define MPIDU_WIN_LOCK_QUEUE(w) ((struct mpid_qhead *)(w)->_dev._lock_queue) > > /** \brief Test whether lock queue has no waiters */ > #define MPIDU_LOCK_QUEUE_EMPTY(w) \ > (MPIDU_WIN_LOCK_QUEUE(w)->blocks == NULL || \ > MPIDU_WIN_LOCK_QUEUE(w)->blocks->next_used == NULL) > > /** \brief Test if lock is unlocked */ > #define MPID_LOCK_IS_FREE(w) ((w)->_dev.lock_granted == 0) > /** \brief Test if lock is locked exclusive */ > #define MPID_LOCK_IS_EXCL(w) ((w)->_dev.lock_granted & INT_MSB) > /** \brief Test if lock is locked shared */ > #define MPID_LOCK_IS_SHARE(w) ((w)->_dev.lock_granted && \ > !((w)->_dev.lock_granted & INT_MSB)) > /** \brief Test if lock is locked exclusive by rank 'r' */ > #define MPID_LOCK_ISMY_EXCL(w, r) \ > ((w)->_dev.lock_granted == ((r) | INT_MSB)) > /** \brief Test if lock is locked shared by rank 'r' \note Can't tell who's locked shared */ > #define MPID_LOCK_ISMY_SHARE(w, r) \ > ((w)->_dev.lock_granted && \ > !((w)->_dev.lock_granted & INT_MSB)) > > /** \brief Test if lock is OK to lock exclusive */ > #define MPID_LOCK_OK_EXCL(w) ((w)->_dev.lock_granted == 0) > /** \brief Test if lock is OK to lock shared */ > #define MPID_LOCK_OK_SHARE(w) (!((w)->_dev.lock_granted & INT_MSB)) > > /** \brief Lock the lock in exclusive mode */ > #define MPID_LOCK_EXCL(w, r) ((w)->_dev.lock_granted = (r) | INT_MSB) > /** \brief Unlock the lock (from exclusive mode) */ > #define MPID_UNLOCK_EXCL(w, r) ((w)->_dev.lock_granted = 0) > /** \brief Lock the lock in shared mode */ > #define MPID_LOCK_SHARE(w, r) (++(w)->_dev.lock_granted) > /** \brief Unlock the lock (from shared mode) */ > #define MPID_UNLOCK_SHARE(w, r) (--(w)->_dev.lock_granted) > > /** > * \brief Examine local lock and return current lock type. > * > * \param[in] win Window object containing lock in question > * \return Lock type (status): > * - \e MPI_LOCK_EXCLUSIVE - locked in exclusive mode. > * - \e MPI_LOCK_SHARED - locked by one or more nodes in shared mode. > * - \e 0 - not locked. > * > * \ref rsrc_design\n > * \ref lock_wait_design > */ > static int local_lock_type(MPID_Win *win) { > MPID_assert_debug(MPI_LOCK_EXCLUSIVE != 0 && > MPI_LOCK_SHARED != 0); > if (MPID_LOCK_IS_FREE(win)) { > return 0; > } else if (MPID_LOCK_IS_EXCL(win)) { > return MPI_LOCK_EXCLUSIVE; > } else /* MPID_LOCK_IS_SHARE(win) */ { > return MPI_LOCK_SHARED; > } > } > > /** > * \brief Local lock routine. > * > * Called from lock receive callback. > * Also sets epoch_rma_ok if lock is acquired. > * > * \param[in] win Pointer to MPID_Win structure > * \param[in] orig Rank of origin (locker) > * \param[in] type Type of lock being requested > * \return 1 if the lock was granted, or > * 0 if the lock was refused (caller must wait). > * > * \ref lock_design\n > * \ref rsrc_design\n > * \ref lock_wait_design > */ > static unsigned local_lock(MPID_Win *win, int orig, int type) { > if (type == MPI_LOCK_EXCLUSIVE) { > if (MPID_LOCK_OK_EXCL(win)) { > MPID_LOCK_EXCL(win, orig); > return 1; > } > } else /* type == MPI_LOCK_SHARED */ { > if (MPID_LOCK_OK_SHARE(win)) { > MPID_LOCK_SHARE(win, orig); > MPID_assert_debug(MPID_LOCK_OK_SHARE(win)); > return 1; > } > } > return 0; > } > > /** > * \brief Local unlock routine. > * > * Called from unlock receive callback. > * Gets origin (unlocker) rank, (expected) lock type, and origin RMA > * ops count (number of RMA ops that node originated to this node). > * Returns -1 if the lock is not in appropriate state to be unlocked > * (by the calling node and expected lock type). > * Clears epoch_rma_ok if lock is released (completely - i.e. last > * shared lock release). > * > * \param[in] win Pointer to MPID_Win structure > * \param[in] orig Rank of origin (locker) > * \return 1 if the lock was released, or > * 0 if the lock was "busy". > * > * \ref lock_design\n > * \ref rsrc_design\n > * \ref lock_wait_design > */ > static unsigned local_unlock(MPID_Win *win, int orig) { > MPID_assert_debug(!MPID_LOCK_IS_FREE(win)); > if (MPID_LOCK_IS_EXCL(win)) { > MPID_UNLOCK_EXCL(win, orig); > } else if (MPID_LOCK_IS_SHARE(win)) { > MPID_UNLOCK_SHARE(win, orig); > MPID_assert_debug(MPID_LOCK_OK_SHARE(win)); > } > return 1; > } > > /** \brief Number of Lock Wait Queue elements per allocation block */ > #define MPIDU_NUM_ALLOC_WAITERS 7 > /** > * \brief Lock Wait Queue Element > * > * \ref rsrc_design\n > * \ref lock_wait_design > */ > struct mpid_lock_waiter { > struct mpid_lock_waiter *next; /**< next used or next free */ > int waiter_rank; /**< rank requesting lock */ > int lock_type; /**< lock type requested */ > int *_pad; /**< pad to even fraction of cacheline */ > MPIDU_Onesided_ctl_t ackinfo; /**< dcmf context (opaque) info. > * Not directly used in communications. */ > }; > /** \brief Padding for Lock Wait Queue Element resource block header */ > #define MPIDU_PAD_ALLOC_WAITERS \ > (sizeof(struct mpid_lock_waiter) - sizeof(struct mpid_resource)) > > /** > * \brief Setup a lock wait queue entry. > * > * Adds a new waiter to the (end of the) wait queue. > * Saves rank, type, and ackinfo in the wait object. > * Typically called from lock receive callback. > * > * A lock type of 0 (none) is used as a "break-point" to > * ensure non-lock epoch starts will eventually succeed. > * > * \param[in] win Pointer to MPID_Win structure > * \param[in] rank Rank of origin (locker) > * \param[in] type Type of lock being requested > * \param[in] ackinfo Additional info to save on queue (may be NULL) > * \return nothing > * > * \ref rsrc_design\n > * \ref lock_wait_design > */ > static void MPIDU_add_waiter(MPID_Win *win, int rank, int type, > MPIDU_Onesided_ctl_t *ackinfo) { > struct mpid_lock_waiter wp; > > wp.waiter_rank = rank; > wp.lock_type = type; > if (ackinfo) { > wp.ackinfo = *ackinfo; > } else { > memset(&wp.ackinfo, 0, sizeof(wp.ackinfo)); > } > (void)MPIDU_add_element(MPIDU_WIN_LOCK_QUEUE(win), &wp); > } > > /** > * \brief Conditionally pops next waiter off lock wait queue. > * > * Returns the next waiter on the window lock, provided its desired > * lock type is compatible with the current lock status. > * Fills in rank, type, and ackinfo with pertinent data, > * on success. Called by unlock (recv callback). If lock status > * (after the unlock) is (still) shared, then the next waiter must > * want shared (probably not a likely scenario since it should have > * been granted the lock when requested). However, this check ensures > * that an exclusive lock waiter cannot grab a lock that is still in > * shared mode. Typically called from unlock receive callback. > * > * \param[in] win Pointer to MPID_Win structure > * \param[out] rank Rank of origin (locker) > * \param[out] type Type of lock being requested > * \param[out] ackinfo Additional info from original lock call (may be NULL) > * \return 0 if lock waiter was popped, or > * 1 if the queue was empty or next waiter incompatible > * > * \ref lock_design\n > * \ref rsrc_design\n > * \ref lock_wait_design > */ > static int MPIDU_pop_waiter(MPID_Win *win, int *rank, int *type, > MPIDU_Onesided_ctl_t *ackinfo) { > struct mpid_lock_waiter wp; > struct mpid_resource *lq = MPIDU_WIN_LOCK_QUEUE(win)->blocks; > int lt; > > if (lq == NULL || lq->next_used == NULL) { > return 1; /* no one waiting */ > } > if (MPIDU_peek_element(MPIDU_WIN_LOCK_QUEUE(win), &wp)) { > return 1; /* no one waiting */ > } > if (!rank && !type && wp.lock_type != 0) { > return 1; /* not our marker... */ > } > lt = local_lock_type(win); > if (lt == MPI_LOCK_EXCLUSIVE || > (lt != 0 && lt != wp.lock_type)) { > return 1; /* not a compatible waiter */ > } > (void)MPIDU_pop_element(MPIDU_WIN_LOCK_QUEUE(win), NULL); > if (rank) { > *rank = wp.waiter_rank; > } > if (type) { > *type = wp.lock_type; > } > if (ackinfo) { > *ackinfo = wp.ackinfo; > } > return 0; > } > > /** > * \brief Progress (advance) wait for window lock to be released > * > * Adds a dummy waiter to the lock wait queue, so ensure that > * unlock will eventually give us a chance. > * > * Called from various epoch-start code to ensure no other node is > * accessing our window while we are in another epoch. > * > * \todo Probably sohuld assert that the popped waiter, > * if any, was our NULL one. > * > * \param[in] win Pointer to MPID_Win object > * \return nothing > */ > void MPIDU_Spin_lock_free(MPID_Win *win) { > MPIDU_add_waiter(win, 0, 0, NULL); > MPIDU_Progress_spin(!MPID_LOCK_IS_FREE(win)); > MPIDU_pop_waiter(win, NULL, NULL, NULL); > } > > int MPIDU_is_lock_free(MPID_Win *win) { > return MPID_LOCK_IS_FREE(win); > } > > /* > * * * * * Unlock wait queue * * * * * > */ > > /** > * \page unlk_wait_design Unlock Wait Queue Design > * > * The Unlock Wait Queue is used to delay unlocking of a > * window until all outstanding RMA operations have completed. > * > * Each unlock request includes the number of RMA operations > * that were initiated by that origin. When the unlock is attempted, > * this number is compared to the count of RMA ops received from that > * origin and if the numbers do not match the unlock request is queued. > * > * Whenever an RMA operation is processed, the routine \e rma_recvs_cb() > * is called and the unlock wait queue is checked for an entry from that > * origin node, and that the counts now match. If so, the unlock is dequeued > * and the lock released (acknowledge message sent to origin). > * > * Note that this unlock may include granting of the lock to other > * nodes (i.e. processing of the lock wait queue). > * > * \ref lock_wait_design > */ > > /** > * \brief Shortcut for accessing the lock waiter queue > * object in the window structure. > */ > #define MPIDU_WIN_UNLK_QUEUE(w) ((struct mpid_qhead *)(w)->_dev._unlk_queue) > > /** \brief Number of Unlock Wait Queue elements per allocation block */ > #define MPIDU_NUM_UNLK_ENTRIES 7 > /** > * \brief Unlock Wait Queue Element > */ > struct mpid_unlk_entry { > struct mpid_unlk_entry *next; /**< next used or next free */ > int rank; /**< origin rank (unlocker) */ > int rmas; /**< number of rmas sent by origin */ > int _pad; /**< pad to power of 2 size */ > }; > /** \brief Padding for Datatype Cache Element resource block header */ > #define MPIDU_PAD_UNLK_ENTRIES 0 > > void mpidu_init_lock(MPID_Win *win) { > MPIDU_INIT_QHEAD(MPIDU_WIN_LOCK_QUEUE(win), > MPIDU_NUM_ALLOC_WAITERS, > sizeof(struct mpid_lock_waiter), > MPIDU_PAD_ALLOC_WAITERS); > MPIDU_INIT_QHEAD(MPIDU_WIN_UNLK_QUEUE(win), > MPIDU_NUM_UNLK_ENTRIES, > sizeof(struct mpid_unlk_entry), > MPIDU_PAD_UNLK_ENTRIES); > } > > void mpidu_free_lock(MPID_Win *win) { > MPID_assert_debug(MPIDU_WIN_LOCK_QUEUE(win)->blocks == NULL || > MPIDU_WIN_LOCK_QUEUE(win)->blocks->next_used == NULL); > MPIDU_free_resource(MPIDU_WIN_LOCK_QUEUE(win)); > MPIDU_free_resource(MPIDU_WIN_UNLK_QUEUE(win)); > } > > /** > * \brief Callback function to match unlock wait queue entry > * > * 'v1' is a struct mpid_unlk_entry with rank and rmas filled in with > * desired origin rank and current RMA ops count from origin. > * 'v2' is the (currrent) struct mpid_unlk_entry being examined as > * a potential match. > * > * Returns success (match) if an unlock element exists with origin rank > * and the expected RMA ops count from that rank has been reached. > * > * \param[in] v1 Desired unlock queue pseudo-element > * \param[in] v2 Unlock queue element to compare with 'v1' > * \param[in] v3 not used > * \return boolean indicating if 'v2' matches 'v1'. > * > * \ref unlk_wait_design > */ > static int mpid_match_unlk(void *v1, void *v2, void *v3) { > struct mpid_unlk_entry *w1 = (struct mpid_unlk_entry *)v1; > struct mpid_unlk_entry *w2 = (struct mpid_unlk_entry *)v2; > > return (w1->rank != w2->rank || w1->rmas < w2->rmas); > } > > /** > * \brief Locate the desired unlocker if it is waiting > * > * Does not return success unless the RMA ops counters match. > * > * \param[in] win Pointer to window > * \param[in] rank Origin rank (unlocker) > * \param[out] ctl Reconstructed UNLOCK message, if unlocker found > * > * \ref unlk_wait_design > * \ref msginfo_usage > */ > static struct mpid_unlk_entry *MPIDU_locate_unlk(MPID_Win *win, int rank, MPIDU_Onesided_ctl_t *ctl) { > struct mpid_unlk_entry el, *ep; > struct mpid_element *pp = NULL; > > el.rank = rank; > el.rmas = win->_dev.coll_info[rank].rma_sends; > ep = MPIDU_find_element(MPIDU_WIN_UNLK_QUEUE(win), mpid_match_unlk, NULL, &el, &pp); > if (ep) { > if (ctl) { > ctl->mpid_ctl_w0 = MPID_MSGTYPE_UNLOCK; > ctl->mpid_ctl_w1 = win->handle; > ctl->mpid_ctl_w2 = ep->rank; > ctl->mpid_ctl_w3 = ep->rmas; > } > MPIDU_free_element(MPIDU_WIN_UNLK_QUEUE(win), ep, pp); > } > return ep; > } > > /** > * \brief Add an (unsuccessful) unlocker to the wait queue > * > * Decomposes the UNLOCK message to save needed data. > * > * \param[in] win Pointer to window > * \param[in] rank Origin rank (unlocker) > * \param[in] ctl UNLOCK message > * > * \ref unlk_wait_design > * \ref msginfo_usage > */ > static void MPIDU_add_unlk(MPID_Win *win, int rank, const MPIDU_Onesided_ctl_t *ctl) { > struct mpid_unlk_entry wp; > > MPID_assert_debug(ctl != NULL); > MPID_assert_debug(rank == ctl->mpid_ctl_w2); > wp.rank = rank; > wp.rmas = ctl->mpid_ctl_w3; > (void)MPIDU_add_element(MPIDU_WIN_UNLK_QUEUE(win), &wp); > } > > /** > * \brief Callback invoked to count an RMA operation received > * > * Increments window's \e my_rma_recvs counter. > * If window lock is held, then also increment RMA counter > * for specific origin node, and check whether this RMA op > * completes the epoch and an unlock is waiting to be processed. > * > * We use \e rma_sends to count received RMA ops because we > * know we won't be using that to count sent RMA ops since > * we cannot be in an access epoch while in a LOCK exposure epoch. > * > * Called from both the "long message" completion callbacks and > * the "short message" receive callback, in case of PUT or > * ACCUMULATE only. > * > * \param[in] win Pointer to MPID_Win object > * \param[in] orig Rank of originator of RMA operation > * \param[in] lpid lpid of originator of RMA operation > * \return nothing > */ > void rma_recvs_cb(MPID_Win *win, int orig, int lpid) { > ++win->_dev.my_rma_recvs; > if (!MPID_LOCK_IS_FREE(win)) { > struct mpid_unlk_entry *ep; > MPIDU_Onesided_ctl_t ctl; > > ++win->_dev.coll_info[orig].rma_sends; > ep = MPIDU_locate_unlk(win, orig, &ctl); > if (ep) { > unlk_cb(&ctl, lpid); > } > } > } > > /** > * \brief Lock receive callback. > * > * Attempts to acquire the lock. > * On success, sends ACK to origin. > * On failure to acquire lock, > * adds caller to lock wait queue. > * > * Does not attempt to acquire lock (counted as failure) > * if window is currently in some other epoch. > * > * \param[in] info Pointer to msginfo from origin (locker) > * \param[in] lpid lpid of origin node (locker) > * \return nothing > * > * \ref msginfo_usage\n > * \ref lock_design > */ > void lock_cb(const MPIDU_Onesided_ctl_t *info, int lpid) > { > MPID_Win *win; > int ret; > int orig, type; > MPIDU_Onesided_ctl_t ack; > > MPID_assert_debug(info->mpid_ctl_w0 == MPID_MSGTYPE_LOCK); > MPID_Win_get_ptr((MPI_Win)info->mpid_ctl_w1, win); > MPID_assert_debug(win != NULL); > orig = info->mpid_ctl_w2; > type = info->mpid_ctl_w3; > ack.mpid_ctl_w0 = MPID_MSGTYPE_LOCKACK; > ack.mpid_ctl_w1 = win->_dev.coll_info[orig].win_handle; > ack.mpid_ctl_w2 = lpid; > ack.mpid_ctl_w3 = 0; > ret = (win->_dev.epoch_type == MPID_EPOTYPE_NONE && > local_lock(win, orig, type)); > if (!ret) { > MPIDU_add_waiter(win, orig, type, &ack); > } else { > win->_dev.epoch_rma_ok = 1; > (void) DCMF_Control(&bg1s_ct_proto, win->_dev.my_cstcy, lpid, &ack.ctl); > } > } > > /** > * \brief Epoch End callback. > * > * Called whenever epoch_type is set to MPID_EPOTYPE_NONE, i.e. an > * access/exposure epoch ends. Also called when the window lock is > * released (by the origin node). > * > * This is used to prevent locks from being acquired while some other > * access/exposure epoch is active on a window, and queues the lock > * attempt until such time as the epoch has ended. > * > * \param[in] win Pointer to MPID_Win whose epoch has ended > */ > void epoch_end_cb(MPID_Win *win) { > int rank, type, lpid; > MPIDU_Onesided_ctl_t info; > int ret; > > /* > * Wake up any waiting lockers. > * > * This works in the case of a shared-lock release when not all > * lockers have released (no compatible waiter will be found). > * > * This also works in the case of non-lock epochs ending. > * > * An epoch-start call will spin waiting for lock to be released. > * Before spinning, it will queue a waiter with lock type 0 (none), > * so that this loop will not block progress indefinitely. > */ > while (MPIDU_pop_waiter(win, &rank, &type, &info) == 0 && > type != 0) { > /* compatible waiter found */ > ret = local_lock(win, rank, type); > MPID_assert_debug(ret != 0); > if (info.mpid_ctl_w0 == 0) { /* local request */ > ++win->_dev.my_sync_done; > } else { > win->_dev.epoch_rma_ok = 1; > lpid = info.mpid_ctl_w2; > (void) DCMF_Control(&bg1s_ct_proto, win->_dev.my_cstcy, lpid, &info.ctl); > } > } > } > > /** > * \brief Unlock receive callback. > * > * Attempts to release the lock. > * If the lock cannot be released (due to outstanding RMA ops not > * yet received) then the unlocker is placed on a queue where its > * request will be re-evaluated when RMA ops are received. > * If lock can be released, any lock waiters are woken up in > * \e epoch_end_cb() and an MPID_MSGTYPE_UNLOCKACK is sent to the unlocker. > * > * \param[in] info Pointer to msginfo from origin (unlocker) > * \param[in] lpid lpid of origin node (unlocker) > * \return nothing > * > * \ref msginfo_usage\n > * \ref lock_design > */ > void unlk_cb(const MPIDU_Onesided_ctl_t *info, int lpid) { > MPID_Win *win; > unsigned ret; > int orig, rmas; > > MPID_assert_debug(info->mpid_ctl_w0 == MPID_MSGTYPE_UNLOCK); > MPID_Win_get_ptr((MPI_Win)info->mpid_ctl_w1, win); > MPID_assert_debug(win != NULL); > orig = info->mpid_ctl_w2; > rmas = info->mpid_ctl_w3; > ret = ((rmas && win->_dev.coll_info[orig].rma_sends < rmas) || > local_unlock(win, orig)); > if (ret) { /* lock was released */ > MPIDU_Onesided_ctl_t ack; > if (MPID_LOCK_IS_FREE(win)) { > win->_dev.epoch_rma_ok = 0; > } > epoch_end_cb(win); > ack.mpid_ctl_w0 = MPID_MSGTYPE_UNLOCKACK; > ack.mpid_ctl_w1 = win->_dev.coll_info[orig].win_handle; > ack.mpid_ctl_w2 = mpid_my_lpid; > ack.mpid_ctl_w3 = 0; > (void) DCMF_Control(&bg1s_ct_proto, win->_dev.my_cstcy, lpid, &ack.ctl); > } else { > MPIDU_add_unlk(win, orig, info); > } > } > > /** > * \page lock_design MPID_Win_lock / unlock Design > * > * MPID_Win_lock/unlock use DCMF_Control() to send messages (both requests and > * acknowledgements). All aspects of locking, including queueing waiters for > * lock and unlock, is done in this layer, in this source file. > * > * A lock request / RMA / unlock sequence is as follows: > * > * MPI_Win_lock Called > * > * - A sanity-check is done to > * ensure that the window is in a valid state to enter a > * \e LOCK access epoch. These checks include testing that > * no other epoch is currently in affect. > * - If the local window is currenty locked then wait for the > * lock to be released (calling advance in the loop). > * This is made deterministic by inserting a "dummy" waiter on > * the lock wait queue which will cause an unlock to stop > * trying to grant lock waiters. > * - If MPI_MODE_NOCHECK was specified, then return success now. > * - Setup a msginfo structure with the msg type, target window > * handle, our rank, and lock type, and call DCMF_Control to start > * the message on its way to the target. > * Spin waiting for both the message to send and the my_sync_done flag > * to get set (by receive callback of MPID_MSGTYPE_LOCKACK message) indicating the lock > * has been granted. > * > * On the target node the MPID_MSGTYPE_LOCK callback is invoked > * > * - If the lock cannot be granted, either because the target node > * is currently involved in some other access/exposure epoch or the lock > * is currently granted in an incompatible mode: > * - An entry is added to the end of the lock wait queue, > * containing the rank, lock mode, and ack info, > * and the callback returns to the message layer without sending > * MPID_MSGTYPE_LOCKACK, > * which causes the origin node to wait. > * - At some point in the future a node unlocks the window, or the > * current epoch ends, at > * which time this entry is removed from the lock wait queue and > * progress continues with the lock granted. > * - If (when) the lock can be granted, by a call to epoch_end_cb() either from > * a specific MPID_* epoch-ending synchronization or target processing of MPI_Win_unlock(): > * - As long as compatible waiters are found at the head of the lock wait queue, > * an MPID_MSGTYPE_LOCKACK message is created from the waiter info and sent to the > * (each) origin node, causing the origin's my_sync_done flag to get set, waking it up. > * > * Origin wakes up after lock completion > * > * - Set epoch type, target node, and MPI_MODE_* flags in window. > * This effectively creates the epoch. > * > * Origin invokes RMA operation(s) > * > * - See respective RMA operation calls for details > * > * Origin calls MPI_Win_unlock > * > * - Basic sanity-checks are done, including testing that the > * window is actually in a \e LOCK access epoch and that the target > * node specified is the same as the target node of the MPI_Win_lock. > * - If any RMA operations (sends) are pending, wait for them to be > * sent (calling advance in the loop). > * - If MPI_MODE_NOCHECK was not asserted in the original lock call: > * - setup message with the msg type MPID_MSGTYPE_UNLOCK, target window handle, > * our rank, and the number of RMA operations that were initiated > * to this target. > * - Call DCMF_Control, to send the message (unlock request). > * - Spin waiting for message to send and my_sync_done to get set. > * > * On the target node the unlock callback is invoked > * > * - Sanity-check the unlock to ensure it matches the original lock. > * - If the number of RMA operations sent to us by the origin exceeds the number > * of operations received from the origin: > * - add the unlock request to the unlock wait queue. > * Receive callbacks for RMA operations > * will update the RMA ops counter(s) and process any unlock waiters who's > * counts now match. > * - Otherwise, Release the lock: > * - Call epoch_end_cb() which will > * generate MPID_MSGTYPE_LOCKACK messages to all compatible lock waiters. > * - Send an MPID_MSGTYPE_UNLOCKACK message to the origin. This message > * causes the origin's my_sync_done flag to get set, waking it up. > * > * Origin wakes up after unlock completion > * > * - Reset epoch info in window to indicate the epoch has ended. > */ > /// \cond NOT_REAL_CODE > #undef FUNCNAME > #define FUNCNAME MPID_Win_lock > #undef FCNAME > #define FCNAME MPIU_QUOTE(FUNCNAME) > /// \endcond > /** > * \brief MPI-DCMF glue for MPI_WIN_LOCK function > * > * Begin an access epoch to node \e dest. > * Does not return until target has locked window. > * > * epoch_size is overloaded here, since the assumed > * epoch size for MPID_EPOTYPE_LOCK is 1. We use this > * field to save the target (locked) rank. This can > * be used later to validate the target of an RMA operation > * or to sanity-check the unlock. > * > * \param[in] lock_type Lock type (exclusive or shared) > * \param[in] dest Destination rank (target) > * \param[in] assert Synchronization hints > * \param[in] win_ptr Window > * \return MPI_SUCCESS, MPI_ERR_RMA_SYNC, or error returned from > * DCMF_Lock. > * > * \ref msginfo_usage\n > * \ref lock_design > */ > int MPID_Win_lock(int lock_type, int dest, int assert, > MPID_Win *win_ptr) > { > int mpi_errno = MPI_SUCCESS; > MPIDU_Onesided_ctl_t info; > int lpid; > MPIU_THREADPRIV_DECL; > MPID_MPI_STATE_DECL(MPID_STATE_MPID_WIN_LOCK); > > MPID_MPI_FUNC_ENTER(MPID_STATE_MPID_WIN_LOCK); > > MPIU_UNREFERENCED_ARG(assert); > MPIU_THREADPRIV_GET; > MPIR_Nest_incr(); > > if (dest == MPI_PROC_NULL) goto fn_exit; > > if (win_ptr->_dev.epoch_type != MPID_EPOTYPE_NONE) { > /* --BEGIN ERROR HANDLING-- */ > MPIU_ERR_SETANDSTMT(mpi_errno, MPI_ERR_RMA_SYNC, > goto fn_fail, "**rmasync"); > /* --END ERROR HANDLING-- */ > } > /** > * \todo Should we pass NOCHECK along with RMA ops, > * so that target can confirm? > ` */ > if (!(win_ptr->_dev.epoch_assert & MPI_MODE_NOCHECK)) { > if (dest == win_ptr->_dev.comm_ptr->rank) { > MPIDU_Spin_lock_acquire(win_ptr, dest, lock_type); > } else { > info.mpid_ctl_w0 = MPID_MSGTYPE_LOCK; > info.mpid_ctl_w1 = win_ptr->_dev.coll_info[dest].win_handle; > info.mpid_ctl_w2 = win_ptr->_dev.comm_ptr->rank; > info.mpid_ctl_w3 = lock_type; > lpid = MPIDU_world_rank(win_ptr, dest); > win_ptr->_dev.my_sync_done = 0; > mpi_errno = DCMF_Control(&bg1s_ct_proto, win_ptr->_dev.my_cstcy, lpid, &info.ctl); > if (mpi_errno) { MPIU_ERR_POP(mpi_errno); } > MPIDU_Progress_spin(win_ptr->_dev.my_sync_done == 0); > } > } > > win_ptr->_dev.epoch_type = MPID_EPOTYPE_LOCK; > win_ptr->_dev.epoch_size = dest; > win_ptr->_dev.epoch_assert = assert; > > fn_exit: > MPIR_Nest_decr(); > MPID_MPI_FUNC_EXIT(MPID_STATE_MPID_WIN_LOCK); > return mpi_errno; > /* --BEGIN ERROR HANDLING-- */ > fn_fail: > goto fn_exit; > /* --END ERROR HANDLING-- */ > } > > /// \cond NOT_REAL_CODE > #undef FUNCNAME > #define FUNCNAME MPID_Win_unlock > #undef FCNAME > #define FCNAME MPIU_QUOTE(FUNCNAME) > /// \endcond > /** > * \brief MPI-DCMF glue for MPI_WIN_UNLOCK function > * > * End access epoch started by MPID_Win_lock. > * Sends to target the number of RMA ops we performed. > * Target node will not unlock until it has received all RMA ops we sent. > * While unlock failed call advance. > * > * \param[in] dest Destination rank (target) > * \param[in] win_ptr Window > * \return MPI_SUCCESS, MPI_ERR_RMA_SYNC, or error returned from > * DCMF_Unlock. > * > * \ref msginfo_usage\n > * \ref lock_design > */ > int MPID_Win_unlock(int dest, MPID_Win *win_ptr) > { > int mpi_errno = MPI_SUCCESS; > int lpid; > MPIDU_Onesided_ctl_t info; > MPIU_THREADPRIV_DECL; > MPID_MPI_STATE_DECL(MPID_STATE_MPID_WIN_UNLOCK); > > MPID_MPI_FUNC_ENTER(MPID_STATE_MPID_WIN_UNLOCK); > MPIU_THREADPRIV_GET; > MPIR_Nest_incr(); > > if (dest == MPI_PROC_NULL) goto fn_exit; > > if (win_ptr->_dev.epoch_type != MPID_EPOTYPE_LOCK) { > /* --BEGIN ERROR HANDLING-- */ > MPIU_ERR_SETANDSTMT(mpi_errno, MPI_ERR_RMA_SYNC, > goto fn_fail, "**rmasync"); > /* --END ERROR HANDLING-- */ > } > MPID_assert(dest == win_ptr->_dev.epoch_size); > > /* > * We wait for all RMA sends to drain here, just for neatness. > * TBD: It may be possible to do this only in the advance loop > * after the unlock request. > */ > MPIDU_Progress_spin(win_ptr->_dev.my_rma_pends > 0 || > win_ptr->_dev.my_get_pends > 0); > > if (!(win_ptr->_dev.epoch_assert & MPI_MODE_NOCHECK)) { > if (dest == win_ptr->_dev.comm_ptr->rank) { > (void)local_unlock(win_ptr, dest); > /* our (subsequent) call to epoch_end_cb() will > * handle any lock waiters... */ > } else { > info.mpid_ctl_w0 = MPID_MSGTYPE_UNLOCK; > info.mpid_ctl_w1 = win_ptr->_dev.coll_info[dest].win_handle; > info.mpid_ctl_w2 = win_ptr->_dev.comm_ptr->rank; > info.mpid_ctl_w3 = win_ptr->_dev.coll_info[dest].rma_sends; > /* > * Win_unlock should not return until all RMA ops are > * complete at the target. So, we loop here until the > * target tells us all RMA ops are finished. We also > * zero the rma_sends param in the loop, so that the > * target can just always += the number and not get an > * unreasonable number of pending ops, plus should we > * ever decide to do other RMA ops between attempts to > * unlock, we can pass that number to the target and it > * will update its counter. > */ > lpid = MPIDU_world_rank(win_ptr, dest); > win_ptr->_dev.my_sync_done = 0; > mpi_errno = DCMF_Control(&bg1s_ct_proto, win_ptr->_dev.my_cstcy, lpid, &info.ctl); > if (mpi_errno) { MPIU_ERR_POP(mpi_errno); } > MPIDU_Progress_spin(win_ptr->_dev.my_rma_pends > 0 || > win_ptr->_dev.my_get_pends > 0 || > win_ptr->_dev.my_sync_done == 0); > } > } > win_ptr->_dev.epoch_type = MPID_EPOTYPE_NONE; > win_ptr->_dev.epoch_size = 0; > win_ptr->_dev.epoch_assert = 0; > win_ptr->_dev.coll_info[dest].rma_sends = 0; > epoch_end_cb(win_ptr); > > fn_exit: > MPIR_Nest_decr(); > MPID_MPI_FUNC_EXIT(MPID_STATE_MPID_WIN_UNLOCK); > return mpi_errno; > /* --BEGIN ERROR HANDLING-- */ > fn_fail: > goto fn_exit; > /* --END ERROR HANDLING-- */ > } diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/onesided/mpid_win_pscw.c bgp-mpich2/src/mpid/dcmf/src/onesided/mpid_win_pscw.c 0a1,483 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file src/onesided/mpid_win_pscw.c > * \brief MPI-DCMF MPI_Win_post/start/complete/wait(test) functionality > */ > > #include "mpid_onesided.h" > > /** > * \brief Test if MPI_Win_post exposure epoch has ended > * > * Must call advance at least once per call. Tests if all > * MPID_MSGTYPE_COMPLETE messages have been received, and whether > * all RMA ops that were sent have been received. If epoch does end, > * must cleanup all structures, counters, flags, etc. > * > * Assumes that MPID_Progress_start() and MPID_Progress_end() bracket > * this call, in some meaningful fashion. > * > * \param[in] win Window > * \return TRUE if epoch has ended > */ > static int mpid_check_post_done(MPID_Win *win) { > int rank = win->_dev.comm_ptr->rank; > > (void)MPID_Progress_test(); > if (!(win->_dev.epoch_assert & MPI_MODE_NOCHECK) && > (win->_dev.my_sync_done < win->_dev.epoch_size || > win->_dev.my_rma_recvs < win->_dev.coll_info[rank].rma_sends)) { > return 0; > } > win->_dev.epoch_type = MPID_EPOTYPE_NONE; > win->_dev.epoch_size = 0; > win->_dev.epoch_assert = 0; > win->_dev.epoch_rma_ok = 0; > win->_dev.my_sync_done = 0; > win->_dev.my_rma_recvs = 0; > win->_dev.coll_info[rank].rma_sends = 0; > /* > * Any RMA ops we initiated would be handled in a > * Win_start/Win_complete epoch and that would have > * zeroed our target rma_sends. > */ > epoch_end_cb(win); > return 1; > } > > /// \cond NOT_REAL_CODE > #undef FUNCNAME > #define FUNCNAME MPID_Win_complete > #undef FCNAME > #define FCNAME MPIU_QUOTE(FUNCNAME) > /// \endcond > /** > * \brief MPI-DCMF glue for MPI_WIN_COMPLETE function > * > * End the access epoch began by MPID_Win_start. > * Sends a MPID_MSGTYPE_COMPLETE message, containing our count of > * RMA operations sent to that node, to all nodes in the group. > * > * \param[in] win_ptr Window > * \return MPI_SUCCESS, MPI_ERR_RMA_SYNC, or error returned from > * MPIDU_proto_send. > * > * \ref post_design > */ > int MPID_Win_complete(MPID_Win *win_ptr) > { > unsigned pending; > int mpi_errno = MPI_SUCCESS; > MPIU_THREADPRIV_DECL; > MPID_MPI_STATE_DECL(MPID_STATE_MPID_WIN_COMPLETE); > > MPID_MPI_FUNC_ENTER(MPID_STATE_MPID_WIN_COMPLETE); > MPIU_THREADPRIV_GET; > MPIR_Nest_incr(); > > if (win_ptr->_dev.epoch_type != MPID_EPOTYPE_START && > win_ptr->_dev.epoch_type != MPID_EPOTYPE_POSTSTART) { > /* --BEGIN ERROR HANDLING-- */ > MPIU_ERR_SETANDSTMT(mpi_errno, MPI_ERR_RMA_SYNC, > goto fn_fail, "**rmasync"); > /* --END ERROR HANDLING-- */ > } > > if (!(win_ptr->_dev.epoch_assert & MPI_MODE_NOCHECK)) { > /* This zeroes the respective rma_sends counts... */ > mpi_errno = MPIDU_proto_send(win_ptr, win_ptr->start_group_ptr, > MPID_MSGTYPE_COMPLETE); > if (mpi_errno) { MPIU_ERR_POP(mpi_errno); } > } > /* > * MPICH2 says that we cannot return until all RMA ops > * have completed at the origin (i.e. been sent). > * > * Since MPIDU_proto_send() uses DCMF_Control(), there > * are no pending sends to wait for. > */ > MPIDU_Progress_spin(win_ptr->_dev.my_rma_pends > 0 || > win_ptr->_dev.my_get_pends > 0); > win_ptr->start_assert = 0; > MPIU_Object_release_ref(win_ptr->start_group_ptr, &pending); > win_ptr->start_group_ptr = NULL; > if (win_ptr->_dev.epoch_type == MPID_EPOTYPE_POSTSTART) { > win_ptr->_dev.epoch_type = MPID_EPOTYPE_POST; > } else { > win_ptr->_dev.epoch_type = MPID_EPOTYPE_NONE; > win_ptr->_dev.epoch_size = 0; > epoch_end_cb(win_ptr); > } > > fn_exit: > MPIR_Nest_decr(); > MPID_MPI_FUNC_EXIT(MPID_STATE_MPID_WIN_COMPLETE); > return mpi_errno; > > /* --BEGIN ERROR HANDLING-- */ > fn_fail: > goto fn_exit; > /* --END ERROR HANDLING-- */ > } > > /** > * \page post_design MPID_Win_post-start / complete-wait Design > * > * MPID_Win_post and MPID_Win_start take a group object. In > * each case this group object excludes the calling node. > * Each node calling MPID_Win_post or MPID_Win_start may > * specify a different group, however all nodes listed in a > * MPID_Win_start group must call MPID_Win_post, and vice versa. > * A node may call both MPID_Win_post and MPID_Win_start, but > * only in that order. Likewise, MPID_Win_complete and MPID_Win_wait > * (or MPID_Win_test) must be called in that order. > * > * A post-start / RMA / complete-wait sequence is as follows: > * > * The following assumes that all nodes are in-sync with respect to > * synchronization primitives. If not, nodes will fail their > * synchronization calls as appropriate. > * > * All nodes permitting RMA access call MPI_Win_post > * > * - A sanity-check is done to > * ensure that the window is in a valid state to enter a > * \e POST access epoch. These checks include testing that > * no other epoch is currently in affect. > * - If the local window is currenty locked then wait for the > * lock to be released (calling advance in the loop). > * - Set epoch type to MPID_EPOTYPE_POST, epoch size to group size, > * RMA OK flag to TRUE, and save MPI_MODE_* assertions. > * - If MPI_MODE_NOCHECK is set, return MPI_SUCCESS. > * - Send MPID_MSGTYPE_POST protocol messages to all nodes in group. > * - Wait for all sends to complete (not for receives to complete). > * > * All nodes intending to do RMA access call MPI_Win_start > * > * - A sanity-check is done to > * ensure that the window is in a valid state to enter a > * \e START access epoch. These checks include testing that > * either a \e POST epoch or no epoch is currently in affect. > * - If the current epoch is MPID_EPOTYPE_NONE and the > * local window is currenty locked then wait for the > * lock to be released (calling advance in the loop). > * - Set epoch type to MPID_EPOTYPE_START or MPID_EPOTYPE_POSTSTART > * and save MPI_MODE_* \e start assertions. > * - Take a reference on the group and save the \e start group (pointer). > * - If MPI_MODE_NOCHECK is set then return MPI_SUCCESS now. > * - Wait for MPID_MSGTYPE_POST messages to be received from > * all nodes in group. > * > * One or more nodes invoke RMA operation(s) > * > * - See respective RMA operation calls for details > * > * All nodes that intended to do RMA access call MPI_Win_complete > * > * - A sanity-check is done to > * ensure that the window is in a valid state to end a > * \e START access epoch. These checks include testing that > * either a \e START epoch or \e POSTSTART epoch is currently in affect. > * - Send MPID_MSGTYPE_COMPLETE messages to all nodes in the group. > * These messages include the count of RMA operations that were sent. > * - Wait for all messages to send, including RMA operations that > * had not previously gone out (MPICH2 requirement). > * Call advance in the loop. > * - Reset epoch info as appropriate, to state prior to MPID_Win_start > * call (i.e. epoch type either MPID_EPOTYPE_POST or MPID_EPOTYPE_NONE). > * - Release reference on group. > * > * All nodes that allowed RMA access call MPI_Win_wait > * > * MPID_Win_wait and MPID_Win_test are interchangeable, for the sake > * of this discussion. > * > * - A sanity-check is done to > * ensure that the window is in a valid state to end a > * \e POST access epoch. These checks include testing that > * a \e POST epoch is currently in affect. > * - Call advance. > * - Test if MPID_MSGTYPE_COMPLETE messages have been received from > * all nodes in group, and that all RMA operations sent to us have been > * received by us. MPID_Win_test will return FALSE under this condition, > * while MPID_Win_wait will loop back to the "Call advance" step. > * - Reset epoch info to indicate the \e POST epoch has ended. > * - Return TRUE (MPI_SUCCESS). > */ > /// \cond NOT_REAL_CODE > #undef FUNCNAME > #define FUNCNAME MPID_Win_start > #undef FCNAME > #define FCNAME MPIU_QUOTE(FUNCNAME) > /// \endcond > /** > * \brief MPI-DCMF glue for MPI_WIN_START function > * > * Begin an access epoch for nodes in group. > * Waits for all nodes in group to send us a MPID_MSGTYPE_POST message. > * > * \param[in] group_ptr Group > * \param[in] assert Synchronization hints > * \param[in] win_ptr Window > * \return MPI_SUCCESS or MPI_ERR_RMA_SYNC. > * > * \todo In the NOCHECK case, do we still need to Barrier? > * > * \ref post_design > */ > int MPID_Win_start(MPID_Group *group_ptr, int assert, MPID_Win *win_ptr) > { > int mpi_errno = MPI_SUCCESS; > MPIU_THREADPRIV_DECL; > MPID_MPI_STATE_DECL(MPID_STATE_MPID_WIN_START); > > MPID_MPI_FUNC_ENTER(MPID_STATE_MPID_WIN_START); > MPIU_THREADPRIV_GET; > MPIR_Nest_incr(); > if (win_ptr->_dev.epoch_type == MPID_EPOTYPE_NONE) { > MPIDU_Spin_lock_free(win_ptr); > win_ptr->_dev.epoch_type = MPID_EPOTYPE_START; > win_ptr->_dev.epoch_size = group_ptr->size; > } else if (win_ptr->_dev.epoch_type == MPID_EPOTYPE_POST) { > win_ptr->_dev.epoch_type = MPID_EPOTYPE_POSTSTART; > } else { > /* --BEGIN ERROR HANDLING-- */ > MPIU_ERR_SETANDSTMT(mpi_errno, MPI_ERR_RMA_SYNC, > goto fn_fail, "**rmasync"); > /* --END ERROR HANDLING-- */ > } > win_ptr->start_assert = assert; > MPIU_Object_add_ref(group_ptr); > win_ptr->start_group_ptr = group_ptr; > /** > * \todo MPI_MODE_NOCHECK might still include POST messages, > * so the my_sync_begin counter could be incremented. Need to > * ensure it gets zeroed (appropriately) later... This is an > * erroneous condition and needs to be detected and result in > * reasonable failure. > */ > if (!(assert & MPI_MODE_NOCHECK)) { > MPIDU_Progress_spin(win_ptr->_dev.my_sync_begin < group_ptr->size); > win_ptr->_dev.my_sync_begin = 0; > } > > fn_exit: > MPIR_Nest_decr(); > MPID_MPI_FUNC_EXIT(MPID_STATE_MPID_WIN_START); > return mpi_errno; > > /* --BEGIN ERROR HANDLING-- */ > fn_fail: > goto fn_exit; > /* --END ERROR HANDLING-- */ > } > > /// \cond NOT_REAL_CODE > #undef FUNCNAME > #define FUNCNAME MPID_Win_post > #undef FCNAME > #define FCNAME MPIU_QUOTE(FUNCNAME) > /// \endcond > /** > * \brief MPI-DCMF glue for MPI_WIN_POST function > * > * Begin an exposure epoch on nodes in group. Sends MPID_MSGTYPE_POST > * message to all nodes in group. > * > * \param[in] group_ptr Group > * \param[in] assert Synchronization hints > * \param[in] win_ptr Window > * \return MPI_SUCCESS, MPI_ERR_RMA_SYNC, or error returned from > * MPIDU_proto_send. > * > * \ref post_design > */ > int MPID_Win_post(MPID_Group *group_ptr, int assert, MPID_Win *win_ptr) > { > int mpi_errno = MPI_SUCCESS; > volatile unsigned pending = 0; > MPIU_THREADPRIV_DECL; > MPID_MPI_STATE_DECL(MPID_STATE_MPID_WIN_POST); > > MPID_MPI_FUNC_ENTER(MPID_STATE_MPID_WIN_POST); > MPIU_THREADPRIV_GET; > MPIR_Nest_incr(); > if (win_ptr->_dev.epoch_type != MPID_EPOTYPE_NONE) { > /* --BEGIN ERROR HANDLING-- */ > MPIU_ERR_SETANDSTMT(mpi_errno, MPI_ERR_RMA_SYNC, > goto fn_fail, "**rmasync"); > /* --END ERROR HANDLING-- */ > } > MPIDU_Spin_lock_free(win_ptr); > MPID_assert_debug(win_ptr->_dev.my_rma_pends == 0 && > win_ptr->_dev.my_get_pends == 0); > win_ptr->_dev.epoch_size = group_ptr->size; > win_ptr->_dev.epoch_type = MPID_EPOTYPE_POST; > win_ptr->_dev.epoch_assert = assert; > win_ptr->_dev.epoch_rma_ok = 1; > if (assert & MPI_MODE_NOSTORE) { > /* TBD: anything to optimize? */ > } > if (assert & MPI_MODE_NOPUT) { > /* handled later */ > } > /** > * \todo In the NOCHECK case, do we still need to Barrier? > * How do we detect a mismatch of MPI_MODE_NOCHECK in > * Win_post/Win_start? If the _post has NOCHECK but the _start > * did not, the _start will wait forever for the POST messages. > * One option is to still send POST messages in the NOCHECK > * case, and just not wait in the _start. The POST message > * could then send the assert value and allow verification > * when _start nodes call RMA ops. > */ > if (!(assert & MPI_MODE_NOCHECK)) { > mpi_errno = MPIDU_proto_send(win_ptr, group_ptr, > MPID_MSGTYPE_POST); > if (mpi_errno) { MPIU_ERR_POP(mpi_errno); } > /** > * \todo In theory, we could just return now without > * advance/wait. > * MPICH2 says this call "does not block", but is > * waiting for messages to send considered blocking in > * that context? The receiving nodes (in Win_start) > * will not procede with RMA ops until they get this > * message, so we need to ensure reasonable progress > * between the time we call Win_post and Win_wait. > * Also, Win_test is not supposed to block in any > * fashion, so it should not wait for the sends to > * complete either. It seems that the idea is to have > * RMA ops going on while this node is executing code > * between Win_post and Win_wait, but that won't > * happen unless enough calls are made to advance > * during that time... > * "need input"... > */ > MPIDU_Progress_spin(pending > 0); > } > > fn_exit: > MPIR_Nest_decr(); > MPID_MPI_FUNC_EXIT(MPID_STATE_MPID_WIN_POST); > return mpi_errno; > /* --BEGIN ERROR HANDLING-- */ > fn_fail: > goto fn_exit; > /* --END ERROR HANDLING-- */ > } > > /// \cond NOT_REAL_CODE > #undef FUNCNAME > #define FUNCNAME MPID_Win_test > #undef FCNAME > #define FCNAME MPIU_QUOTE(FUNCNAME) > /// \endcond > /** > * \brief MPI-DCMF glue for MPI_WIN_TEST function > * > * Test whether the exposure epoch started by MPID_Win_post has ended. > * If it has ended, clean up and reset window. This routine must call > * advance at least once, for any code path. > * > * \param[in] win_ptr Window > * \param[out] flag Status of synchronization (TRUE = complete) > * \return MPI_SUCCESS or MPI_ERR_RMA_SYNC. > * > * \see mpid_check_post_done > * > * \ref post_design > */ > int MPID_Win_test (MPID_Win *win_ptr, int *flag) > { > int mpi_errno = MPI_SUCCESS; > MPIU_THREADPRIV_DECL; > MPID_MPI_STATE_DECL(MPID_STATE_MPID_WIN_TEST); > > MPID_MPI_FUNC_ENTER(MPID_STATE_MPID_WIN_TEST); > MPIU_THREADPRIV_GET; > MPIR_Nest_incr(); > > if (win_ptr->_dev.epoch_type != MPID_EPOTYPE_POST) { > /* --BEGIN ERROR HANDLING-- */ > MPIU_ERR_SETANDSTMT(mpi_errno, MPI_ERR_RMA_SYNC, > goto fn_fail, "**rmasync"); > /* --END ERROR HANDLING-- */ > } > if ((win_ptr->_dev.epoch_assert & MPI_MODE_NOPUT) && > win_ptr->_dev.my_rma_recvs > 0) { > /* TBD: handled earlier? */ > } > MPID_Progress_start(&dummy_state); > *flag = (mpid_check_post_done(win_ptr) != 0); > MPID_Progress_end(&dummy_state); > > fn_exit: > MPIR_Nest_decr(); > MPID_MPI_FUNC_EXIT(MPID_STATE_MPID_WIN_TEST); > return mpi_errno; > /* --BEGIN ERROR HANDLING-- */ > fn_fail: > goto fn_exit; > /* --END ERROR HANDLING-- */ > } > > /// \cond NOT_REAL_CODE > #undef FUNCNAME > #define FUNCNAME MPID_Win_wait > #undef FCNAME > #define FCNAME MPIU_QUOTE(FUNCNAME) > /// \endcond > /** > * \brief MPI-DCMF glue for MPI_WIN_WAIT function > * > * Wait for exposure epoch started by MPID_Win_post to end. > * > * \param[in] win_ptr Window > * \return MPI_SUCCESS or MPI_ERR_RMA_SYNC. > * > * \see mpid_check_post_done > * > * \ref post_design > */ > int MPID_Win_wait(MPID_Win *win_ptr) > { > int mpi_errno = MPI_SUCCESS; > MPIU_THREADPRIV_DECL; > MPID_MPI_STATE_DECL(MPID_STATE_MPID_WIN_WAIT); > > MPID_MPI_FUNC_ENTER(MPID_STATE_MPID_WIN_WAIT); > MPIU_THREADPRIV_GET; > MPIR_Nest_incr(); > > if (win_ptr->_dev.epoch_type != MPID_EPOTYPE_POST) { > /* --BEGIN ERROR HANDLING-- */ > MPIU_ERR_SETANDSTMT(mpi_errno, MPI_ERR_RMA_SYNC, > goto fn_fail, "**rmasync"); > /* --END ERROR HANDLING-- */ > } > if ((win_ptr->_dev.epoch_assert & MPI_MODE_NOPUT) && > win_ptr->_dev.my_rma_recvs > 0) { > /* TBD: handled earlier? */ > } > MPID_Progress_start(&dummy_state); > while (!mpid_check_post_done(win_ptr)) { > DCMF_CriticalSection_cycle(0); > } > MPID_Progress_end(&dummy_state); > > fn_exit: > MPIR_Nest_decr(); > MPID_MPI_FUNC_EXIT(MPID_STATE_MPID_WIN_WAIT); > return mpi_errno; > /* --BEGIN ERROR HANDLING-- */ > fn_fail: > goto fn_exit; > /* --END ERROR HANDLING-- */ > } diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/persistent/Makefile.sm bgp-mpich2/src/mpid/dcmf/src/persistent/Makefile.sm 0a1,3 > SUBDIRS= . > INCLUDES = -I${master_top_srcdir}/src/include -I${top_builddir}/src/include > lib${MPILIBNAME}_a_SOURCES = mpid_recv_init.c mpid_send_init.c mpid_startall.c diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/persistent/mpid_recv_init.c bgp-mpich2/src/mpid/dcmf/src/persistent/mpid_recv_init.c 0a1,53 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file src/persistent/mpid_recv_init.c > * \brief ??? > */ > > /* This creates and initializes a persistent recv request */ > > #include "mpidimpl.h" > > int MPID_Recv_init(void * buf, > int count, > MPI_Datatype datatype, > int rank, > int tag, > MPID_Comm * comm, > int context_offset, > MPID_Request ** request) > { > MPID_Request * rreq = MPID_Request_create(); > if (rreq == NULL) { > *request = NULL; > return MPIR_ERR_MEMALLOCFAILED; > }; > > MPIU_Object_set_ref(rreq, 1); > rreq->kind = MPID_PREQUEST_RECV; > rreq->comm = comm; > MPIR_Comm_add_ref(comm); > MPID_Request_setMatch(rreq,tag,rank,comm->recvcontext_id + context_offset); > rreq->dcmf.userbuf = (char *) buf; > rreq->dcmf.userbufcount = count; > rreq->dcmf.datatype = datatype; > rreq->partner_request = NULL; > rreq->cc = 0; > > MPID_Request_setType(rreq, MPIDI_DCMF_REQUEST_TYPE_RECV); > if (HANDLE_GET_KIND(datatype) != HANDLE_KIND_BUILTIN) > { > MPID_Datatype_get_ptr(datatype, rreq->dcmf.datatype_ptr); > MPID_Datatype_add_ref(rreq->dcmf.datatype_ptr); > } > > *request = rreq; > return MPI_SUCCESS; > } diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/persistent/mpid_send_init.c bgp-mpich2/src/mpid/dcmf/src/persistent/mpid_send_init.c 0a1,145 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file src/persistent/mpid_send_init.c > * \brief ??? > */ > /* This creates and initializes a persistent send request */ > > #include "mpidimpl.h" > > /** > * *************************************************************************** > * create a persistent send template > * *************************************************************************** > */ > > static inline int > MPID_PSendRequest (const void * buf, > int count, > MPI_Datatype datatype, > int rank, > int tag, > MPID_Comm * comm, > int context_offset, > MPID_Request ** request) > { > (*request) = MPID_SendRequest_create(); > if ((*request) == NULL) return MPIR_ERR_MEMALLOCFAILED; > MPIU_Object_set_ref((*request), 1); > (*request)->kind = MPID_PREQUEST_SEND; > (*request)->comm = comm; > MPIR_Comm_add_ref(comm); > MPID_Request_setMatch((*request),tag,rank,comm->context_id + context_offset); > (*request)->dcmf.userbuf = (void *) buf; > (*request)->dcmf.userbufcount = count; > (*request)->dcmf.datatype = datatype; > (*request)->partner_request = NULL; > (*request)->cc = 0; > > if (HANDLE_GET_KIND(datatype) != HANDLE_KIND_BUILTIN) > { > MPID_Datatype_get_ptr(datatype, (*request)->dcmf.datatype_ptr); > MPID_Datatype_add_ref((*request)->dcmf.datatype_ptr); > } > > return MPI_SUCCESS; > } > > /** > * *************************************************************************** > * simple persistent send > * *************************************************************************** > */ > > int MPID_Send_init(const void * buf, > int count, > MPI_Datatype datatype, > int rank, > int tag, > MPID_Comm * comm, > int context_offset, > MPID_Request ** request) > { > int mpi_errno = MPID_PSendRequest (buf, count, datatype, > rank, tag, comm, context_offset, > request); > if (mpi_errno != MPI_SUCCESS) return mpi_errno; > MPID_Request_setType((*request), MPIDI_DCMF_REQUEST_TYPE_SEND); > return MPI_SUCCESS; > } > > /** > * *************************************************************************** > * persistent ready-send > * *************************************************************************** > */ > > int MPID_Rsend_init(const void * buf, > int count, > MPI_Datatype datatype, > int rank, > int tag, > MPID_Comm * comm, > int context_offset, > MPID_Request ** request) > { > int mpi_errno = MPID_PSendRequest (buf, count, datatype, > rank, tag, comm, context_offset, > request); > if (mpi_errno != MPI_SUCCESS) return mpi_errno; > MPID_Request_setType((*request), MPIDI_DCMF_REQUEST_TYPE_RSEND); > return MPI_SUCCESS; > } > > /** > * *************************************************************************** > * persistent synchronous send > * *************************************************************************** > */ > > int MPID_Ssend_init(const void * buf, > int count, > MPI_Datatype datatype, > int rank, > int tag, > MPID_Comm * comm, > int context_offset, > MPID_Request ** request) > { > int mpi_errno = MPID_PSendRequest (buf, count, datatype, > rank, tag, comm, context_offset, > request); > if (mpi_errno != MPI_SUCCESS) return mpi_errno; > MPID_Request_setType((*request), MPIDI_DCMF_REQUEST_TYPE_SSEND); > return MPI_SUCCESS; > } > > /** > * *************************************************************************** > * persistent buffered send > * *************************************************************************** > */ > > int MPID_Bsend_init(const void * buf, > int count, > MPI_Datatype datatype, > int rank, > int tag, > MPID_Comm * comm, > int context_offset, > MPID_Request ** request) > { > int mpi_errno = MPID_PSendRequest (buf, count, datatype, > rank, tag, comm, context_offset, > request); > if (mpi_errno != MPI_SUCCESS) return mpi_errno; > MPID_Request_setType((*request), MPIDI_DCMF_REQUEST_TYPE_BSEND); > return MPI_SUCCESS; > } diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/persistent/mpid_startall.c bgp-mpich2/src/mpid/dcmf/src/persistent/mpid_startall.c 0a1,137 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file src/persistent/mpid_startall.c > * \brief ??? > */ > #include "mpidimpl.h" > #include "../../../mpi/pt2pt/bsendutil.h" > > int MPID_Startall(int count, MPID_Request * requests[]) > { > int rc=MPI_SUCCESS, i; > for (i = 0; i < count; i++) > { > MPID_Request * const preq = requests[i]; > switch(MPID_Request_getType(preq)) > { > case MPIDI_DCMF_REQUEST_TYPE_RECV: > { > rc = MPID_Irecv(preq->dcmf.userbuf, > preq->dcmf.userbufcount, > preq->dcmf.datatype, > preq->dcmf.msginfo.msginfo.MPIrank, > preq->dcmf.msginfo.msginfo.MPItag, > preq->comm, > preq->dcmf.msginfo.msginfo.MPIctxt - > preq->comm->recvcontext_id, > &preq->partner_request); > break; > } > case MPIDI_DCMF_REQUEST_TYPE_SEND: > { > rc = MPID_Isend(preq->dcmf.userbuf, > preq->dcmf.userbufcount, > preq->dcmf.datatype, > preq->dcmf.msginfo.msginfo.MPIrank, > preq->dcmf.msginfo.msginfo.MPItag, > preq->comm, > preq->dcmf.msginfo.msginfo.MPIctxt - > preq->comm->context_id, > &preq->partner_request); > break; > } > case MPIDI_DCMF_REQUEST_TYPE_RSEND: > { > rc = MPID_Irsend(preq->dcmf.userbuf, > preq->dcmf.userbufcount, > preq->dcmf.datatype, > preq->dcmf.msginfo.msginfo.MPIrank, > preq->dcmf.msginfo.msginfo.MPItag, > preq->comm, > preq->dcmf.msginfo.msginfo.MPIctxt - > preq->comm->context_id, > &preq->partner_request); > break; > } > case MPIDI_DCMF_REQUEST_TYPE_SSEND: > { > rc = MPID_Issend(preq->dcmf.userbuf, > preq->dcmf.userbufcount, > preq->dcmf.datatype, > preq->dcmf.msginfo.msginfo.MPIrank, > preq->dcmf.msginfo.msginfo.MPItag, > preq->comm, > preq->dcmf.msginfo.msginfo.MPIctxt - > preq->comm->context_id, > &preq->partner_request); > break; > } > case MPIDI_DCMF_REQUEST_TYPE_BSEND: > { > MPID_Request * sreq = MPID_Request_create(); > if (sreq != NULL) > { > MPIU_Object_set_ref(sreq, 1); > sreq->kind = MPID_REQUEST_SEND; > sreq->cc = 0; > sreq->comm = preq->comm; > MPIR_Comm_add_ref(sreq->comm); > rc = MPIR_Bsend_isend(preq->dcmf.userbuf, > preq->dcmf.userbufcount, > preq->dcmf.datatype, > preq->dcmf.msginfo.msginfo.MPIrank, > preq->dcmf.msginfo.msginfo.MPItag, > preq->comm, > BSEND_INIT, > &preq->partner_request); > sreq->status.MPI_ERROR = rc; > preq->partner_request = sreq; > rc = MPI_SUCCESS; > } > else > { > rc = MPIR_Err_create_code(MPI_SUCCESS, > MPIR_ERR_FATAL, > "MPID_Startall", > __LINE__, > MPI_ERR_OTHER, > "**nomem", > 0); > } > break; > } > > default: > { > rc = MPIR_Err_create_code(MPI_SUCCESS, MPIR_ERR_FATAL, "MPID_Startall", __LINE__, MPI_ERR_INTERN,"**ch3|badreqtype","**ch3|badreqtype %d",MPID_Request_getType(preq)); > } > > } /* switch should end here, bug fixed. */ > > if (rc == MPI_SUCCESS) > { > preq->status.MPI_ERROR = MPI_SUCCESS; > preq->cc_ptr = &preq->partner_request->cc; > } > else > { > /* If a failure occurs attempting to start the request, > then we assume that partner request was not created, > and stuff the error code in the persistent request. > The wait and test routines will look at the error code > in the persistent request if a partner request is not present. */ > preq->partner_request = NULL; > preq->status.MPI_ERROR = rc; > preq->cc_ptr = &preq->cc; > preq->cc = 0; > } > } /* for */ > return rc; > } diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/pt2pt/Makefile.sm bgp-mpich2/src/mpid/dcmf/src/pt2pt/Makefile.sm 0a1,21 > SUBDIRS= . > INCLUDES = -I${master_top_srcdir}/src/include -I${top_builddir}/src/include > lib${MPILIBNAME}_a_SOURCES = \ > mpidi_isend_self.c \ > mpid_irecv.c \ > mpid_irsend.c \ > mpid_isend.c \ > mpid_issend.c \ > mpid_recv.c \ > mpid_rsend.c \ > mpid_send.c \ > mpid_ssend.c \ > mpid_cancel_recv.c \ > mpid_cancel_send.c \ > mpidi_callback.c \ > mpidi_callback_rzv.c \ > mpidi_callback_short.c \ > mpidi_control.c \ > mpidi_startmessage.c \ > mpidi_rendezvous.c \ > mpidi_done.c diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/pt2pt/mpid_cancel_recv.c bgp-mpich2/src/mpid/dcmf/src/pt2pt/mpid_cancel_recv.c 0a1,27 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file src/pt2pt/mpid_cancel_recv.c > * \brief Device interface for canceling an MPI Recv > */ > #include "mpidimpl.h" > > int MPID_Cancel_recv(MPID_Request * rreq) > { > MPID_assert(rreq->kind == MPID_REQUEST_RECV); > if (MPIDI_Recvq_FDPR(rreq)) > { > rreq->status.cancelled = TRUE; > rreq->status.count = 0; > MPID_Request_set_completed(rreq); > MPID_Request_release(rreq); > } > /* This is successful, even if the recv isn't cancelled */ > return MPI_SUCCESS; > } diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/pt2pt/mpid_cancel_send.c bgp-mpich2/src/mpid/dcmf/src/pt2pt/mpid_cancel_send.c 0a1,61 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file src/pt2pt/mpid_cancel_send.c > * \brief Device interface for canceling an MPI Send > */ > #include "mpidimpl.h" > > int MPID_Cancel_send(MPID_Request * sreq) > { > int flag; > MPID_assert(sreq != NULL); > > /* ------------------------------------------------- */ > /* Check if we already have a cancel request pending */ > /* ------------------------------------------------- */ > MPIDI_DCMF_Request_cancel_pending(sreq, &flag); > if (flag) > return MPI_SUCCESS; > > /* ------------------------------------ */ > /* Try to cancel a send request to self */ > /* ------------------------------------ */ > if (MPID_Request_isSelf(sreq)) > { > MPID_Request * rreq; > rreq = MPIDI_Recvq_FDUR(sreq); > if (rreq) > { > MPID_assert(rreq->partner_request == sreq); > MPIU_Object_set_ref(rreq, 0); > MPID_Request_destroy(rreq); > sreq->status.cancelled = TRUE; > sreq->cc = 0; > MPIU_Object_set_ref(sreq, 1); > } > return MPI_SUCCESS; > } > else > { > if (sreq->dcmf.state == MPIDI_DCMF_ACKNOWLEGED) > { > MPID_assert(0 == *sreq->cc_ptr); > MPIU_Object_add_ref(sreq); > MPID_Request_increment_cc(sreq); > } > > if(!sreq->comm) > return MPI_SUCCESS; > > MPIDI_DCMF_postCancelReq(sreq); > > return MPI_SUCCESS; > } > } diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/pt2pt/mpidi_callback.c bgp-mpich2/src/mpid/dcmf/src/pt2pt/mpidi_callback.c 0a1,189 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file src/pt2pt/mpidi_callback.c > * \brief The standard callback for a new message > */ > #include "mpidimpl.h" > > /** > * \brief The standard callback for a new message > * \param[in] clientdata Unused > * \param[in] msginfo The 16-byte msginfo struct > * \param[in] count The number of msginfo quads (1) > * \param[in] senderrank The sender's rank > * \param[in] sndlen The length of the incoming data > * \param[out] rcvlen The amount we are willing to receive > * \param[out] rcvbuf Where we want to put the data > * \param[out] cb_info Callback information for message completion > * \returns Storage for the DCMF to use for managing the message > */ > DCMF_Request_t * MPIDI_BG2S_RecvCB(void * clientdata, > const MPIDI_DCMF_MsgInfo * msginfo, > unsigned count, > unsigned senderrank, > const unsigned sndlen, > unsigned * rcvlen, > char ** rcvbuf, > DCMF_Callback_t * const cb_info) > { > MPID_Request * rreq = NULL; > int found; > *rcvlen = sndlen; > > /* -------------------------- */ > /* match request */ > /* -------------------------- */ > MPIDI_Message_match match; > match.rank = msginfo->msginfo.MPIrank; > match.tag = msginfo->msginfo.MPItag; > match.context_id = msginfo->msginfo.MPIctxt; > > rreq = MPIDI_Recvq_FDP_or_AEU(match.rank, match.tag, match.context_id, &found); > > if (rreq == NULL) > { > /* ------------------------------------------------- */ > /* we have failed to match the request. */ > /* allocate and initialize a request object instead. */ > /* ------------------------------------------------- */ > > int mpi_errno = MPIR_Err_create_code(MPI_SUCCESS, > MPIR_ERR_FATAL, > "mpid_recv", > __LINE__, > MPI_ERR_OTHER, > "**nomem", 0); > rreq->status.MPI_ERROR = mpi_errno; > rreq->status.count = 0; > MPID_Abort(NULL, mpi_errno, -1, "Cannot allocate message"); > } > > /* -------------------------------------- */ > /* Signal that the recv has been started. */ > /* -------------------------------------- */ > MPID_Progress_signal (); > > /* ------------------------ */ > /* copy in information */ > /* ------------------------ */ > rreq->status.MPI_SOURCE = match.rank; > rreq->status.MPI_TAG = match.tag; > MPID_Request_setPeerRank(rreq,senderrank); > MPID_Request_setPeerRequest(rreq,msginfo->msginfo.req); > MPID_Request_setSync(rreq, msginfo->msginfo.isSync); > MPID_Request_setRzv(rreq, 0); > > /* -------------------------------------------------------- */ > /* we have enough information to fill in the callback info. */ > /* -------------------------------------------------------- */ > cb_info->function = (void (*)(void *))MPIDI_DCMF_RecvDoneCB; > cb_info->clientdata = (void *)rreq; > > /* ----------------------------------------- */ > /* figure out target buffer for request data */ > /* ----------------------------------------- */ > MPID_Request_setCA(rreq, MPIDI_DCMF_CA_COMPLETE); > rreq->status.count = *rcvlen; > if (found) > { > /* --------------------------- */ > /* request was already posted. */ > /* if synchronized, post ack. */ > /* --------------------------- */ > if (msginfo->msginfo.isSync) > MPIDI_DCMF_postSyncAck(rreq); > > /* -------------------------------------- */ > /* calculate message length for reception */ > /* calculate receive message "count" */ > /* -------------------------------------- */ > unsigned dt_contig, dt_size; > MPID_Datatype *dt_ptr; > MPI_Aint dt_true_lb; > MPIDI_Datatype_get_info (rreq->dcmf.userbufcount, > rreq->dcmf.datatype, > dt_contig, > dt_size, > dt_ptr, > dt_true_lb); > > /* -------------------------------------- */ > /* test for truncated message. */ > /* -------------------------------------- */ > if (*rcvlen > dt_size) > { > *rcvlen = dt_size; > rreq->status.MPI_ERROR = MPI_ERR_TRUNCATE; > rreq->status.count = *rcvlen; > } > > /* -------------------------------------- */ > /* if buffer is contiguous, we are done. */ > /* -------------------------------------- */ > if (dt_contig) > { > > rreq->dcmf.uebuf = NULL; > rreq->dcmf.uebuflen = 0; > *rcvbuf = (char *)rreq->dcmf.userbuf + dt_true_lb; > > /* Whitespace to sync lines of code with mpidi_callback_short.c */ > /* ------------------------------------------------------------- */ > > return &rreq->dcmf.msg; > } > > /* --------------------------------------------- */ > /* buffer is non-contiguous. we need to allocate */ > /* a temporary buffer, and unpack later. */ > /* --------------------------------------------- */ > else > { > MPID_Request_setCA(rreq, MPIDI_DCMF_CA_UNPACK_UEBUF_AND_COMPLETE); > > /* > * > * Whitespace to sync lines of code with mpidi_callback_short.c > * > */ > } > } > > /* ------------------------------------------------------------- */ > /* fallback position: request was not posted or not contiguous */ > /* We must allocate enough space to hold the message temporarily */ > /* the temporary buffer will be unpacked later. */ > /* ------------------------------------------------------------- */ > rreq->dcmf.uebuflen = *rcvlen; > if ((rreq->dcmf.uebuf = MPIU_Malloc (*rcvlen)) == NULL) > { > /* ------------------------------------ */ > /* creation of temporary buffer failed. */ > /* we are in trouble and must bail out. */ > /* ------------------------------------ */ > > int mpi_errno = MPIR_Err_create_code(MPI_SUCCESS, > MPIR_ERR_FATAL, > "mpid_recv", > __LINE__, > MPI_ERR_OTHER, > "**nomem", 0); > rreq->status.MPI_ERROR = mpi_errno; > rreq->status.count = 0; > MPID_Abort(NULL, mpi_errno, -1, "Cannot allocate unexpected buffer"); > } > > /* ------------------------------------------------ */ > /* set up outgoing variables */ > /* ------------------------------------------------ */ > *rcvbuf = rreq->dcmf.uebuf; > > return &rreq->dcmf.msg; > } diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/pt2pt/mpidi_callback_rzv.c bgp-mpich2/src/mpid/dcmf/src/pt2pt/mpidi_callback_rzv.c 0a1,106 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file src/pt2pt/mpidi_callback_rzv.c > * \brief The callback for a new RZV RTS > */ > #include "mpidimpl.h" > > /** > * \brief The callback for a new RZV RTS > * \note Because this is a short message, the data is already received > * \param[in] clientdata Unused > * \param[in] rzv_envelope The 16-byte msginfo struct > * \param[in] count The number of msginfo quads (1) > * \param[in] senderrank The sender's rank > * \param[in] sndlen The length of the incoming data > * \param[in] sndbuf Where the data is stored > */ > void MPIDI_BG2S_RecvRzvCB(void * clientdata, > const MPIDI_DCMF_RzvEnvelope * rzv_envelope, > unsigned count, > unsigned senderrank, > const char * sndbuf, > unsigned sndlen) > { > MPID_Request * rreq = NULL; > MPIDI_DCMF_MsgInfo * msginfo = (MPIDI_DCMF_MsgInfo *)&rzv_envelope->msginfo; > int found; > > > /* -------------------------- */ > /* match request */ > /* -------------------------- */ > MPIDI_Message_match match; > match.rank = msginfo->msginfo.MPIrank; > match.tag = msginfo->msginfo.MPItag; > match.context_id = msginfo->msginfo.MPIctxt; > > rreq = MPIDI_Recvq_FDP_or_AEU(match.rank, match.tag, match.context_id, &found); > > if (rreq == NULL) > { > /* ------------------------------------------------- */ > /* we have failed to match the request. */ > /* allocate and initialize a request object instead. */ > /* ------------------------------------------------- */ > > int mpi_errno = MPIR_Err_create_code(MPI_SUCCESS, > MPIR_ERR_FATAL, > "mpid_recv", > __LINE__, > MPI_ERR_OTHER, > "**nomem", 0); > rreq->status.MPI_ERROR = mpi_errno; > rreq->status.count = 0; > MPID_Abort(NULL, mpi_errno, -1, "Cannot allocate message"); > } > > /* -------------------------------------- */ > /* Signal that the recv has been started. */ > /* -------------------------------------- */ > MPID_Progress_signal (); > > /* ------------------------ */ > /* copy in information */ > /* ------------------------ */ > rreq->status.MPI_SOURCE = match.rank; > rreq->status.MPI_TAG = match.tag; > MPID_Request_setPeerRank(rreq,senderrank); > MPID_Request_setPeerRequest(rreq,msginfo->msginfo.req); > MPID_Request_setSync(rreq, msginfo->msginfo.isSync); > MPID_Request_setRzv(rreq, 1); > > /* ----------------------------------------------------- */ > /* Save the rendezvous information for when the target */ > /* node calls a receive function and the data is */ > /* retreived from the origin node. */ > /* ----------------------------------------------------- */ > MPIDI_DCMF_RzvInfo * rzvinfo = (MPIDI_DCMF_RzvInfo *)&rzv_envelope->rzvinfo; > rreq->status.count = rzvinfo->sndlen; > rreq->dcmf.rzvinfo.sndlen = rzvinfo->sndlen; > rreq->dcmf.rzvinfo.sndbuf = rzvinfo->sndbuf; > > /* ----------------------------------------- */ > /* figure out target buffer for request data */ > /* ----------------------------------------- */ > if (found) > { > MPIDI_DCMF_RendezvousTransfer (rreq); > } > > /* ------------------------------------------------------------- */ > /* Request was not posted. */ > /* ------------------------------------------------------------- */ > else > { > rreq->dcmf.uebuf = NULL; > rreq->dcmf.uebuflen = 0; > } > } diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/pt2pt/mpidi_callback_short.c bgp-mpich2/src/mpid/dcmf/src/pt2pt/mpidi_callback_short.c 0a1,185 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file src/pt2pt/mpidi_callback_short.c > * \brief The standard callback for a new short message > */ > #include "mpidimpl.h" > > /** > * \brief The standard callback for a new short message > * \note Because this is a short message, the data is already received > * \param[in] clientdata Unused > * \param[in] msginfo The 16-byte msginfo struct > * \param[in] count The number of msginfo quads (1) > * \param[in] senderrank The sender's rank > * \param[in] sndlen The length of the incoming data > * \param[in] sndbuf Where the data is stored > */ > void MPIDI_BG2S_RecvShortCB(void * clientdata, > const MPIDI_DCMF_MsgInfo * msginfo, > unsigned count, > unsigned senderrank, > const char * sndbuf, > unsigned sndlen) > { > MPID_Request * rreq = NULL; > int found; > int rcvlen = sndlen; > > /* -------------------------- */ > /* match request */ > /* -------------------------- */ > MPIDI_Message_match match; > match.rank = msginfo->msginfo.MPIrank; > match.tag = msginfo->msginfo.MPItag; > match.context_id = msginfo->msginfo.MPIctxt; > > rreq = MPIDI_Recvq_FDP_or_AEU(match.rank, match.tag, match.context_id, &found); > > if (rreq == NULL) > { > /* ------------------------------------------------- */ > /* we have failed to match the request. */ > /* allocate and initialize a request object instead. */ > /* ------------------------------------------------- */ > > int mpi_errno = MPIR_Err_create_code(MPI_SUCCESS, > MPIR_ERR_FATAL, > "mpid_recv", > __LINE__, > MPI_ERR_OTHER, > "**nomem", 0); > rreq->status.MPI_ERROR = mpi_errno; > rreq->status.count = 0; > MPID_Abort(NULL, mpi_errno, -1, "Cannot allocate message"); > } > > /* -------------------------------------- */ > /* Signal that the recv has been started. */ > /* -------------------------------------- */ > MPID_Progress_signal (); > > /* ------------------------ */ > /* copy in information */ > /* ------------------------ */ > rreq->status.MPI_SOURCE = match.rank; > rreq->status.MPI_TAG = match.tag; > MPID_Request_setPeerRank(rreq,senderrank); > MPID_Request_setPeerRequest(rreq,msginfo->msginfo.req); > MPID_Request_setSync(rreq, msginfo->msginfo.isSync); > MPID_Request_setRzv(rreq, 0); > > /* > * > * Whitespace to sync lines of code with mpidi_callback.c > * > */ > > /* ----------------------------------------- */ > /* figure out target buffer for request data */ > /* ----------------------------------------- */ > MPID_Request_setCA(rreq, MPIDI_DCMF_CA_COMPLETE); > rreq->status.count = rcvlen; > if (found) > { > /* --------------------------- */ > /* request was already posted. */ > /* if synchronized, post ack. */ > /* --------------------------- */ > if (msginfo->msginfo.isSync) > MPIDI_DCMF_postSyncAck(rreq); > > /* -------------------------------------- */ > /* calculate message length for reception */ > /* calculate receive message "count" */ > /* -------------------------------------- */ > unsigned dt_contig, dt_size; > MPID_Datatype *dt_ptr; > MPI_Aint dt_true_lb; > MPIDI_Datatype_get_info (rreq->dcmf.userbufcount, > rreq->dcmf.datatype, > dt_contig, > dt_size, > dt_ptr, > dt_true_lb); > > /* -------------------------------------- */ > /* test for truncated message. */ > /* -------------------------------------- */ > if (rcvlen > dt_size) > { > rcvlen = dt_size; > rreq->status.MPI_ERROR = MPI_ERR_TRUNCATE; > rreq->status.count = rcvlen; > } > > /* -------------------------------------- */ > /* if buffer is contiguous ... */ > /* -------------------------------------- */ > if (dt_contig) > { > char *rcvbuf; > rreq->dcmf.uebuf = NULL; > rreq->dcmf.uebuflen = 0; > rcvbuf = (char *)rreq->dcmf.userbuf + dt_true_lb; > > memcpy(rcvbuf, sndbuf, rcvlen); > MPIDI_DCMF_RecvDoneCB(rreq); > > return; > } > > /* --------------------------------------------- */ > /* buffer is non-contiguous. we need to specify */ > /* the send buffer as temporary and unpack. */ > /* --------------------------------------------- */ > else > { > MPID_Request_setCA(rreq, MPIDI_DCMF_CA_UNPACK_UEBUF_AND_COMPLETE_NOFREE); > > rreq->dcmf.uebuflen = rcvlen ; > rreq->dcmf.uebuf = (char *) sndbuf ; > > MPIDI_DCMF_RecvDoneCB(rreq); > return; > } > } > > /* ------------------------------------------------------------- */ > /* Request was not posted. We must allocate enough space to hold */ > /* the message temporarily and copy the data into the temporary */ > /* buffer. The temporary buffer will be unpacked later. */ > /* ------------------------------------------------------------- */ > rreq->dcmf.uebuflen = rcvlen ; > if ((rreq->dcmf.uebuf = MPIU_Malloc (rcvlen)) == NULL) > { > /* ------------------------------------ */ > /* creation of temporary buffer failed. */ > /* we are in trouble and must bail out. */ > /* ------------------------------------ */ > > int mpi_errno = MPIR_Err_create_code(MPI_SUCCESS, > MPIR_ERR_FATAL, > "mpid_recv", > __LINE__, > MPI_ERR_OTHER, > "**nomem", 0); > rreq->status.MPI_ERROR = mpi_errno; > rreq->status.count = 0; > MPID_Abort(NULL, mpi_errno, -1, "Cannot allocate unexpected buffer"); > } > > /* ------------------------------------------------ */ > /* Copy the data into the unexpected buffer. */ > /* ------------------------------------------------ */ > memcpy(rreq->dcmf.uebuf, sndbuf, rreq->dcmf.uebuflen); > MPIDI_DCMF_RecvDoneCB(rreq); > return; > } diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/pt2pt/mpidi_control.c bgp-mpich2/src/mpid/dcmf/src/pt2pt/mpidi_control.c 0a1,223 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file src/pt2pt/mpidi_control.c > * \brief Interface to the control protocols used by MPID pt2pt > */ > #include "mpidimpl.h" > > > /** > * \brief Send a high-priority msginfo struct (control data) > * > * \param[in] control The pointer to the msginfo structure > * \param[in] peerrank The node to whom the control message is to be sent > * > * \return The same as DCMF_Control() > */ > static inline int MPIDI_DCMF_CtrlSend(MPIDI_DCMF_MsgInfo * control, unsigned peerrank) > { > int rc; > MPID_assert_debug(sizeof(DCMF_Control_t) == sizeof(MPIDI_DCMF_MsgInfo)); > rc = DCMF_Control(&MPIDI_Protocols.control, > DCMF_MATCH_CONSISTENCY, > peerrank, > control->quad); > return rc; > } > > > > > /** > * \brief Acknowledge an MPI_Ssend() > * > * \param[in] req The request element to acknowledge > * > * \return The same as MPIDI_DCMF_CtrlSend() > */ > int MPIDI_DCMF_postSyncAck(MPID_Request * req) > { > unsigned peerrank = req->dcmf.peerrank; > MPIDI_DCMF_MsgInfo * info = &req->dcmf.msginfo; > info->msginfo.type = MPIDI_DCMF_REQUEST_TYPE_SSEND_ACKNOWLEDGE; > return MPIDI_DCMF_CtrlSend(info, peerrank); > } > > /** > * \brief Process an incoming MPI_Ssend() acknowledgment > * > * \param[in] info The contents of the control message as a MPIDI_DCMF_MsgInfo struct > * \param[in] peer The rank of the node sending the data > */ > static inline void MPIDI_DCMF_procSyncAck(MPIDI_DCMF_MsgInfo *info, unsigned peer) > { > MPID_Request *infoRequest = (MPID_Request *)info->msginfo.req; > MPID_assert(infoRequest != NULL); > > if(infoRequest->dcmf.state == MPIDI_DCMF_SEND_COMPLETE) > MPID_Request_complete(infoRequest); > else > infoRequest->dcmf.state = MPIDI_DCMF_ACKNOWLEGED; > } > > > > /** > * \brief Cancel an MPI_Send() > * > * \param[in] req The request element to cancel > * > * \return The same as MPIDI_DCMF_CtrlSend() > */ > int MPIDI_DCMF_postCancelReq(MPID_Request * req) > { > MPID_assert(req != NULL); > > MPIDI_DCMF_MsgInfo control; > control.msginfo.MPItag = req->dcmf.msginfo.msginfo.MPItag; > control.msginfo.MPIrank = req->dcmf.msginfo.msginfo.MPIrank; > control.msginfo.MPIctxt = req->dcmf.msginfo.msginfo.MPIctxt; > control.msginfo.type = MPIDI_DCMF_REQUEST_TYPE_CANCEL_REQUEST; > control.msginfo.req = req; > > return MPIDI_DCMF_CtrlSend(&control, MPID_Request_getPeerRank(req)); > } > > /** > * \brief Process an incoming MPI_Send() cancelation > * > * \param[in] info The contents of the control message as a MPIDI_DCMF_MsgInfo struct > * \param[in] peer The rank of the node sending the data > */ > static inline void MPIDI_DCMF_procCancelReq(MPIDI_DCMF_MsgInfo *info, unsigned peer) > { > MPIDI_DCMF_REQUEST_TYPE type; > MPIDI_DCMF_MsgInfo ackinfo; > MPID_Request *sreq = NULL; > MPID_Comm *comm_world = NULL; > > assert(info != NULL); > assert(info->msginfo.req != NULL); > > MPID_Comm_get_ptr(MPI_COMM_WORLD, comm_world ); > sreq=MPIDI_Recvq_FDURSTC(info->msginfo.req, > info->msginfo.MPIrank, > info->msginfo.MPItag, > info->msginfo.MPIctxt); > if(sreq) > { > sreq->status.cancelled = TRUE; > sreq->dcmf.ca = MPIDI_DCMF_CA_DISCARD_UEBUF_AND_COMPLETE; > type = MPIDI_DCMF_REQUEST_TYPE_CANCEL_ACKNOWLEDGE; > } > else > type = MPIDI_DCMF_REQUEST_TYPE_CANCEL_NOT_ACKNOWLEDGE; > > ackinfo.msginfo.type = type; > ackinfo.msginfo.req = info->msginfo.req; > MPIDI_DCMF_CtrlSend(&ackinfo, peer); > } > > > > /** > * \brief Process an incoming MPI_Send() cancelation result > * > * \param[in] info The contents of the control message as a MPIDI_DCMF_MsgInfo struct > * \param[in] peer The rank of the node sending the data > */ > static inline void MPIDI_DCMF_procCanelAck(MPIDI_DCMF_MsgInfo *info, unsigned peer) > { > MPID_Request *infoRequest = (MPID_Request *)info->msginfo.req; > MPID_assert(infoRequest != NULL); > > if(info->msginfo.type == MPIDI_DCMF_REQUEST_TYPE_CANCEL_ACKNOWLEDGE) > infoRequest->status.cancelled = TRUE; > else if(info->msginfo.type == MPIDI_DCMF_REQUEST_TYPE_CANCEL_NOT_ACKNOWLEDGE) > ; > else > MPID_abort(); > > MPID_assert(infoRequest->dcmf.cancel_pending == TRUE); > if( > (infoRequest->dcmf.state==MPIDI_DCMF_REQUEST_DONE_CANCELLED) || > (infoRequest->dcmf.state==MPIDI_DCMF_SEND_COMPLETE) || > (infoRequest->dcmf.state==MPIDI_DCMF_ACKNOWLEGED) > ) > { > infoRequest->dcmf.state=MPIDI_DCMF_REQUEST_DONE_CANCELLED; > MPID_Request_complete(infoRequest); > } > else if (info->msginfo.type == MPIDI_DCMF_REQUEST_TYPE_CANCEL_ACKNOWLEDGE) > { > infoRequest->dcmf.state=MPIDI_DCMF_REQUEST_DONE_CANCELLED; > if (infoRequest->dcmf.msginfo.msginfo.isRzv) > { > /* > * Rendezvous Sends wait until a rzv ack is received to complete the > * send. Since this request was canceled, no rzv ack will be sent > * from the target node, and the send done callback must be > * explicitly called here. > */ > MPIDI_DCMF_SendDoneCB(infoRequest); > } > } > > return; > } > > > /** > * \brief Process an incoming rendezvous acknowledgment from the > * target (remote) node and complete the MPI_Send() on the origin > * (local) node. > * > * \param[in] info The contents of the control message as a MPIDI_DCMF_MsgInfo struct > * \param[in] peer The rank of the node sending the data > */ > static inline void MPIDI_DCMF_procRzvAck(MPIDI_DCMF_MsgInfo *info, unsigned peer) > { > MPID_assert(info->msginfo.req != NULL); > MPIDI_DCMF_SendDoneCB((MPID_Request *)info->msginfo.req); > } > > > /** > * \brief This is the general PT2PT control message call-back > * > * \param[in] clientdata Opaque client data > * \param[in] p The contents of the control message as a DCMF_Control_t > * \param[in] peer The rank of the node sending the data > */ > void MPIDI_BG2S_ControlCB(void *clientdata, const DCMF_Control_t * p, unsigned peer) > { > MPID_assert_debug(sizeof(DCMF_Control_t) == sizeof(MPIDI_DCMF_MsgInfo)); > MPIDI_DCMF_MsgInfo * info = (MPIDI_DCMF_MsgInfo *) p; > > switch (info->msginfo.type) > { > case MPIDI_DCMF_REQUEST_TYPE_SSEND_ACKNOWLEDGE: > MPIDI_DCMF_procSyncAck(info, peer); > break; > case MPIDI_DCMF_REQUEST_TYPE_CANCEL_REQUEST: > MPIDI_DCMF_procCancelReq(info, peer); > break; > case MPIDI_DCMF_REQUEST_TYPE_CANCEL_ACKNOWLEDGE: > case MPIDI_DCMF_REQUEST_TYPE_CANCEL_NOT_ACKNOWLEDGE: > MPIDI_DCMF_procCanelAck(info, peer); > break; > case MPIDI_DCMF_REQUEST_TYPE_RENDEZVOUS_ACKNOWLEDGE: > MPIDI_DCMF_procRzvAck(info, peer); > break; > default: > MPID_abort(); > } > MPID_Progress_signal(); > } diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/pt2pt/mpidi_done.c bgp-mpich2/src/mpid/dcmf/src/pt2pt/mpidi_done.c 0a1,150 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file src/pt2pt/mpidi_done.c > * \brief "Done" call-backs provided to the message layer for signaling completion > */ > #include "mpidimpl.h" > > > /** > * \brief Message layer callback which is invoked on the origin node > * when the send of the message is done > * > * \param[in,out] sreq MPI receive request object > */ > void MPIDI_DCMF_SendDoneCB (MPID_Request * sreq) > { > MPID_assert(sreq != NULL); > > if (sreq->dcmf.uebuf) > MPIU_Free(sreq->dcmf.uebuf); > sreq->dcmf.uebuf = NULL; > > > if(sreq->dcmf.cancel_pending == TRUE) > { > if(sreq->dcmf.state==MPIDI_DCMF_REQUEST_DONE_CANCELLED) > MPID_Request_complete(sreq); > else > sreq->dcmf.state=MPIDI_DCMF_REQUEST_DONE_CANCELLED; > } > else if(MPID_Request_getType(sreq) == MPIDI_DCMF_REQUEST_TYPE_SSEND) > { > if(sreq->dcmf.state == MPIDI_DCMF_ACKNOWLEGED) > MPID_Request_complete(sreq); > else > sreq->dcmf.state = MPIDI_DCMF_SEND_COMPLETE; > } > else > { > sreq->dcmf.state = MPIDI_DCMF_ACKNOWLEGED; > MPID_Request_complete(sreq); > } > } > > > /** > * \brief Message layer callback which is invoked on the target node > * when the incoming message is complete. > * > * \param[in,out] rreq MPI receive request object > */ > void MPIDI_DCMF_RecvDoneCB (MPID_Request * rreq) > { > MPID_assert(rreq != NULL); > switch (rreq->dcmf.ca) > { > case MPIDI_DCMF_CA_UNPACK_UEBUF_AND_COMPLETE: > { > int smpi_errno; > MPID_assert(rreq->dcmf.uebuf != NULL); > // It is unsafe to check the user buffer against NULL. > // Believe it or not, an IRECV can legally be posted with a NULL buffer. > // MPID_assert(rreq->dcmf.userbuf != NULL); > MPIDI_DCMF_Buffer_copy (rreq->dcmf.uebuf, /* source buffer */ > rreq->dcmf.uebuflen, > MPI_CHAR, > &smpi_errno, > rreq->dcmf.userbuf, /* dest buffer */ > rreq->dcmf.userbufcount, /* dest count */ > rreq->dcmf.datatype, /* dest type */ > (MPIDI_msg_sz_t*)&rreq->status.count, > &rreq->status.MPI_ERROR); > /* free the unexpected data buffer */ > MPIU_Free(rreq->dcmf.uebuf); rreq->dcmf.uebuf = NULL; > MPID_Request_complete(rreq); > break; > } > case MPIDI_DCMF_CA_UNPACK_UEBUF_AND_COMPLETE_NOFREE: > { > int smpi_errno; > MPID_assert(rreq->dcmf.uebuf != NULL); > // It is unsafe to check the user buffer against NULL. > // Believe it or not, an IRECV can legally be posted with a NULL buffer. > // MPID_assert(rreq->dcmf.userbuf != NULL); > MPIDI_DCMF_Buffer_copy (rreq->dcmf.uebuf, /* source buffer */ > rreq->dcmf.uebuflen, > MPI_CHAR, > &smpi_errno, > rreq->dcmf.userbuf, /* dest buffer */ > rreq->dcmf.userbufcount, /* dest count */ > rreq->dcmf.datatype, /* dest type */ > (MPIDI_msg_sz_t*)&rreq->status.count, > &rreq->status.MPI_ERROR); > MPID_Request_complete(rreq); > break; > } > case MPIDI_DCMF_CA_COMPLETE: > { > MPID_Request_complete(rreq); > break; > } > case MPIDI_DCMF_CA_DISCARD_UEBUF_AND_COMPLETE: > { > MPIU_Object_set_ref (rreq, 0); > MPID_Request_destroy (rreq); > break; > } > default: > { > MPID_Abort(NULL, MPI_ERR_OTHER, -1, "Internal: unknown CA"); > break; > } > } > } > > > /** > * \brief Message layer callback which is invoked on the target node > * of a flow-control rendezvous operation. > * > * This callback is invoked when the data buffer on the origin node > * has been completely transfered to the target node. The target node > * must acknowledge the completion of the transfer to the origin node > * with a control message and then complete the receive by releasing > * the request object. > * > * \param[in,out] rreq MPI receive request object > */ > void MPIDI_DCMF_RecvRzvDoneCB (MPID_Request * rreq) > { > MPID_assert(rreq != NULL); > > /* Is it neccesary to save the original value of the 'type' field ?? */ > unsigned original_value = rreq->dcmf.msginfo.msginfo.type; > rreq->dcmf.msginfo.msginfo.type = MPIDI_DCMF_REQUEST_TYPE_RENDEZVOUS_ACKNOWLEDGE; > DCMF_Control (&MPIDI_Protocols.control, > DCMF_MATCH_CONSISTENCY, > rreq->dcmf.peerrank, > rreq->dcmf.msginfo.quad); > rreq->dcmf.msginfo.msginfo.type = original_value; > > MPIDI_DCMF_RecvDoneCB (rreq); > } diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/pt2pt/mpidi_isend_self.c bgp-mpich2/src/mpid/dcmf/src/pt2pt/mpidi_isend_self.c 0a1,187 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file src/pt2pt/mpidi_isend_self.c > * \brief Handle the case where the sends are posted to self > */ > #include "mpidimpl.h" > > /** > * \brief Handle the case where the sends are posted to self > * > * \param[in] buf The buffer to send > * \param[in] count Number of elements in the buffer > * \param[in] datatype The datatype of each element > * \param[in] rank The destination rank > * \param[in] tag The message tag > * \param[in] comm Pointer to the communicator > * \param[in] context_offset Offset from the communicator context ID > * \param[in] type The type of send requested > * \param[out] request Return a pointer to the new request object > * > * \returns An MPI Error code > */ > int MPIDI_Isend_self(const void * buf, > int count, > MPI_Datatype datatype, > int rank, > int tag, > MPID_Comm * comm, > int context_offset, > int type, > MPID_Request ** request) > { > MPIDI_Message_match match; > MPID_Request * sreq; > MPID_Request * rreq; > int found; > > /* --------------------- */ > /* create a send request */ > /* --------------------- */ > > if (!(sreq = MPID_SendRequest_create())) > { > *request = NULL; > int mpi_errno = MPIR_Err_create_code(MPI_SUCCESS, > MPIR_ERR_FATAL, > "mpid_send", > __LINE__, > MPI_ERR_OTHER, > "**nomem", 0); > return mpi_errno; > } > MPID_Request_setType (sreq, type); > sreq->dcmf.userbuf = (char *)buf; > sreq->dcmf.userbufcount = count; > sreq->dcmf.datatype = datatype; > sreq->status.count = count; > MPID_Request_setSelf (sreq, 1); > > /* ------------------------------------------ */ > /* attempt to find a matching receive request */ > /* ------------------------------------------ */ > > match.rank = rank; > match.tag = tag; > match.context_id = comm->context_id + context_offset; > rreq = MPIDI_Recvq_FDP_or_AEU(match.rank, match.tag, match.context_id, &found); > if (rreq == NULL) > { > int mpi_errno; > MPIU_Object_set_ref(sreq, 0); > MPID_Request_destroy(sreq); > *request = NULL; > mpi_errno = MPIR_Err_create_code(MPI_SUCCESS, > MPIR_ERR_RECOVERABLE, > "MPID_Isend", > __LINE__, > MPI_ERR_OTHER, > "**nomem", > 0); > return mpi_errno; > } > > /* ------------------------------------------ */ > /* set rreq status. */ > /* ------------------------------------------ */ > rreq->status.MPI_SOURCE = rank; > rreq->status.MPI_TAG = tag; > rreq->status.count = count * MPID_Datatype_get_basic_size(datatype); > > if (found) > { > /* ------------------------------------------ */ > /* we found the posted receive */ > /* ------------------------------------------ */ > MPIDI_msg_sz_t data_sz; > > MPIDI_DCMF_Buffer_copy(buf, /* source buffer */ > count, > datatype, > &sreq->status.MPI_ERROR, > rreq->dcmf.userbuf, /* dest buffer */ > rreq->dcmf.userbufcount, > rreq->dcmf.datatype, > &data_sz, > &rreq->status.MPI_ERROR); > > rreq->status.count = data_sz; > MPID_Request_set_completed(rreq); > MPID_Request_release(rreq); > > /* sreq has never been seen by the user or outside this thread, > so it is safe to reset ref_count and cc */ > sreq->cc = 0; > MPIU_Object_set_ref(sreq, 1); > *request = sreq; > sreq->comm = comm; > sreq->kind = MPID_REQUEST_SEND; > MPID_Request_setMatch(sreq, match.rank, match.tag, match.context_id); > MPIR_Comm_add_ref(comm); > sreq->status.count = data_sz; > return MPI_SUCCESS; > } > > else if (type != MPIDI_DCMF_REQUEST_TYPE_RSEND) > { > /* ---------------------------------------------- */ > /* no corresponding posted receive has been found */ > /* we have added the new *unexpected* receive req */ > /* to the queue, and are attaching sreq to it. */ > /* ---------------------------------------------- */ > if (HANDLE_GET_KIND(datatype) != HANDLE_KIND_BUILTIN) > { > MPID_Datatype_get_ptr(datatype, sreq->dcmf.datatype_ptr); > MPID_Datatype_add_ref(sreq->dcmf.datatype_ptr); > } > rreq->partner_request = sreq; > *request = sreq; > sreq->comm = comm; > sreq->kind = MPID_REQUEST_SEND; > MPID_Request_setMatch(sreq,match.tag, match.rank, match.context_id); > MPIR_Comm_add_ref(comm); > MPID_Request_setSelf (rreq, 1); /* it's a self request */ > MPID_Progress_signal(); /* Signal any waiter. */ > return MPI_SUCCESS; > } > else > { > /* --------------------------------------------- */ > /* no corresponding poster receive, and this was */ > /* a ready send. this is an error. */ > /* --------------------------------------------- */ > sreq->status.MPI_ERROR = MPIR_Err_create_code(MPI_SUCCESS, > MPIR_ERR_FATAL, > "mpid_isend_self", > __LINE__, > MPI_ERR_OTHER, > "**rsendnomatch", 0); > rreq->status.MPI_ERROR = MPIR_Err_create_code(MPI_SUCCESS, > MPIR_ERR_FATAL, > "mpid_isend_self", > __LINE__, > MPI_ERR_OTHER, > "**rsendnomatch", 0); > rreq->partner_request = NULL; > rreq->status.count = 0; > > /* sreq has never been seen by the user or outside > this thread, so it is safe to reset ref_count and cc */ > MPIU_Object_set_ref(sreq, 1); > sreq->cc = 0; > *request = sreq; > sreq->comm = comm; > sreq->kind = MPID_REQUEST_SEND; > MPID_Request_setMatch(sreq, match.tag, match.rank, match.context_id); > MPIR_Comm_add_ref(comm); > MPID_Request_setSelf(rreq,1); > return MPI_SUCCESS; > } > } diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/pt2pt/mpid_irecv.c bgp-mpich2/src/mpid/dcmf/src/pt2pt/mpid_irecv.c 0a1,232 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file src/pt2pt/mpid_irecv.c > * \brief ADI level implemenation of MPI_Irecv() > */ > #include "mpidimpl.h" > > /** > * \brief ADI level implemenation of MPI_Irecv() > * > * \param[in] buf The buffer to receive into > * \param[in] count Number of expected elements in the buffer > * \param[in] datatype The datatype of each element > * \param[in] rank The sending rank > * \param[in] tag The message tag > * \param[in] comm Pointer to the communicator > * \param[in] context_offset Offset from the communicator context ID > * > * \param[out] request Return a pointer to the new request object > * > * \returns An MPI Error code > */ > int MPID_Irecv(void * buf, > int count, > MPI_Datatype datatype, > int rank, > int tag, > MPID_Comm * comm, > int context_offset, > > MPID_Request ** request) > { > int mpi_errno = MPI_SUCCESS; > int found; > MPID_Request * rreq; > > /* ---------------------------------------- */ > /* NULL rank means empty request */ > /* ---------------------------------------- */ > if (rank == MPI_PROC_NULL) > { > rreq = MPID_Request_create(); > if (!rreq) > return MPIR_Err_create_code(MPI_SUCCESS, > MPIR_ERR_FATAL, > "MPID_Irecv", > __LINE__, > MPI_ERR_OTHER, > "**nomem", > 0); > MPIU_Object_set_ref(rreq, 1); > rreq->cc = 0; > rreq->kind = MPID_REQUEST_RECV; > MPIR_Status_set_procnull(&rreq->status); > rreq->comm = comm; > MPIR_Comm_add_ref(comm); > MPID_Request_setMatch(rreq, tag, rank, comm->recvcontext_id+context_offset); > rreq->dcmf.userbuf = buf; > rreq->dcmf.userbufcount = count; > rreq->dcmf.datatype = datatype; > *request = rreq; > return MPI_SUCCESS; > } > > /* ---------------------------------------- */ > /* find our request in the unexpected queue */ > /* or allocate one in the posted queue */ > /* ---------------------------------------- */ > rreq = MPIDI_Recvq_FDU_or_AEP(rank, > tag, > comm->recvcontext_id + context_offset, > &found); > > if (rreq == NULL) > { > *request = rreq; > mpi_errno = MPIR_Err_create_code(MPI_SUCCESS, > MPIR_ERR_FATAL, > "MPID_Irecv", > __LINE__, > MPI_ERR_NO_MEM, > "**nomem", > 0); > return mpi_errno; > } > > /* ----------------------------------------------------------------- */ > /* populate request with our data */ > /* We can do this because this is not a multithreaded implementation */ > /* ----------------------------------------------------------------- */ > > rreq->comm = comm; MPIR_Comm_add_ref (comm); > rreq->dcmf.userbuf = buf; > rreq->dcmf.userbufcount = count; > rreq->dcmf.datatype = datatype; > rreq->dcmf.ca = MPIDI_DCMF_CA_COMPLETE; > > if (found) > { > /* ------------------------------------------------------------ */ > /* message was found in unexpected queue */ > /* ------------------------------------------------------------ */ > /* We must acknowledge synchronous send requests */ > /* The recvnew callback will acknowledge the posted messages */ > /* Recv functions will ack the messages that are unexpected */ > /* ------------------------------------------------------------ */ > > if (MPID_Request_isSelf(rreq)) > { > /* ---------------------- */ > /* "SELF" request */ > /* ---------------------- */ > MPID_Request * const sreq = rreq->partner_request; > MPID_assert(sreq != NULL); > MPIDI_DCMF_Buffer_copy(sreq->dcmf.userbuf, > sreq->dcmf.userbufcount, > sreq->dcmf.datatype, > &sreq->status.MPI_ERROR, > buf, > count, > datatype, > (MPIDI_msg_sz_t*)&rreq->status.count, > &rreq->status.MPI_ERROR); > MPID_Request_set_completed(sreq); > MPID_Request_release(sreq); > /* no other thread can possibly be waiting on rreq, > so it is safe to reset ref_count and cc */ > rreq->cc = 0; > MPIU_Object_set_ref(rreq, 1); > *request = rreq; > return rreq->status.MPI_ERROR; > } > > else if (MPID_Request_isRzv(rreq)) > { > /* -------------------------------------------------------- */ > /* Received an unexpected flow-control rendezvous RTS. */ > /* This is very similar to the found/incolplete case */ > /* -------------------------------------------------------- */ > if (HANDLE_GET_KIND(datatype) != HANDLE_KIND_BUILTIN) > { > MPID_Datatype_get_ptr(datatype, rreq->dcmf.datatype_ptr); > MPID_Datatype_add_ref(rreq->dcmf.datatype_ptr); > } > MPIDI_DCMF_RendezvousTransfer (rreq); > > *request = rreq; > return mpi_errno; > } > > else if (*rreq->cc_ptr == 0) > { > /* -------------------------------- */ > /* request is complete */ > /* if sync request, need to ack it. */ > /* -------------------------------- */ > if (MPID_Request_isSync(rreq)) > MPIDI_DCMF_postSyncAck(rreq); > > int smpi_errno; > MPID_assert(rreq->dcmf.uebuf != NULL); > if(rreq->status.cancelled == FALSE) > { > MPIDI_DCMF_Buffer_copy(rreq->dcmf.uebuf, > rreq->dcmf.uebuflen, > MPI_CHAR, > &smpi_errno, > buf, > count, > datatype, > (MPIDI_msg_sz_t*)&rreq->status.count, > &rreq->status.MPI_ERROR); > } > mpi_errno = rreq->status.MPI_ERROR; > MPIU_Free(rreq->dcmf.uebuf); rreq->dcmf.uebuf = NULL; > /* JRATT : The following were not here originally, but are copied from mpid_recv.c */ > /* if (status != MPI_STATUS_IGNORE) { *status = rreq->status; } */ > > /* MPID_Request_release(rreq); */ > /* rreq = NULL; */ > *request = rreq; > return mpi_errno; > } > > else > { > /* ----------------------- */ > /* request is incomplete. */ > /* ----------------------- */ > if (MPID_Request_isSync(rreq)) > MPIDI_DCMF_postSyncAck(rreq); > > if(rreq->status.cancelled == FALSE) > { > if (rreq->dcmf.uebuf) /* we have an unexpected buffer */ > rreq->dcmf.ca = MPIDI_DCMF_CA_UNPACK_UEBUF_AND_COMPLETE; > else /* no unexpected buffer; must be a resend */ > // MPIDI_DCMF_postFC (rreq, 0); /* send a NAK */ > MPID_abort(); > } > if (HANDLE_GET_KIND(datatype) != HANDLE_KIND_BUILTIN) > { > MPID_Datatype_get_ptr(datatype, rreq->dcmf.datatype_ptr); > MPID_Datatype_add_ref(rreq->dcmf.datatype_ptr); > } > *request = rreq; > return mpi_errno; > } > } > else > { > /* ----------------------------------------------------------- */ > /* request not found in unexpected queue, allocated and posted */ > /* ----------------------------------------------------------- */ > > if (HANDLE_GET_KIND(datatype) != HANDLE_KIND_BUILTIN) > { > MPID_Datatype_get_ptr(datatype, rreq->dcmf.datatype_ptr); > MPID_Datatype_add_ref(rreq->dcmf.datatype_ptr); > } > *request = rreq; > return mpi_errno; > } > return mpi_errno; > } diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/pt2pt/mpidi_rendezvous.c bgp-mpich2/src/mpid/dcmf/src/pt2pt/mpidi_rendezvous.c 0a1,106 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file src/pt2pt/mpidi_rendezvous.c > * \brief Provide for a flow-control rendezvous-based send > */ > #include "mpidimpl.h" > > inline void MPIDI_DCMF_RendezvousTransfer (MPID_Request * rreq) > { > char *rcvbuf; > unsigned rcvlen; > > /* --------------------------- */ > /* if synchronized, post ack. */ > /* --------------------------- */ > if (MPID_Request_isSync(rreq)) > MPIDI_DCMF_postSyncAck(rreq); > > /* -------------------------------------- */ > /* calculate message length for reception */ > /* calculate receive message "count" */ > /* -------------------------------------- */ > unsigned dt_contig, dt_size; > MPID_Datatype *dt_ptr; > MPI_Aint dt_true_lb; > MPIDI_Datatype_get_info (rreq->dcmf.userbufcount, > rreq->dcmf.datatype, > dt_contig, > dt_size, > dt_ptr, > dt_true_lb); > > /* -------------------------------------- */ > /* test for truncated message. */ > /* -------------------------------------- */ > if (rreq->dcmf.rzvinfo.sndlen > dt_size) > { > rcvlen = dt_size; > rreq->status.MPI_ERROR = MPI_ERR_TRUNCATE; > rreq->status.count = rcvlen; > } > else > { > rcvlen = rreq->dcmf.rzvinfo.sndlen; > } > > /* -------------------------------------- */ > /* if buffer is contiguous ... */ > /* -------------------------------------- */ > if (dt_contig) > { > MPID_Request_setCA(rreq, MPIDI_DCMF_CA_COMPLETE); > rreq->dcmf.uebuf = NULL; > rreq->dcmf.uebuflen = 0; > rcvbuf = (char *)rreq->dcmf.userbuf + dt_true_lb; > } > > /* --------------------------------------------- */ > /* buffer is non-contiguous. we need to allocate */ > /* a temporary buffer, and unpack later. */ > /* --------------------------------------------- */ > else > { > MPID_Request_setCA(rreq, MPIDI_DCMF_CA_UNPACK_UEBUF_AND_COMPLETE); > rreq->dcmf.uebuflen = rcvlen ; > if ((rreq->dcmf.uebuf = MPIU_Malloc (rcvlen)) == NULL) > { > /* ------------------------------------ */ > /* creation of temporary buffer failed. */ > /* we are in trouble and must bail out. */ > /* ------------------------------------ */ > > int mpi_errno = MPIR_Err_create_code(MPI_SUCCESS, > MPIR_ERR_FATAL, > "mpid_recv", > __LINE__, > MPI_ERR_OTHER, > "**nomem", 0); > rreq->status.MPI_ERROR = mpi_errno; > rreq->status.count = 0; > MPID_Abort(NULL, mpi_errno, -1, "Cannot allocate unexpected buffer"); > } > > rcvbuf = rreq->dcmf.uebuf; > } > > /* ---------------------------------------------------------------- */ > /* Get the data from the origin node. */ > /* ---------------------------------------------------------------- */ > DCMF_Callback_t cb = { (void (*)(void *))MPIDI_DCMF_RecvRzvDoneCB, (void *) rreq }; > DCMF_Get (&MPIDI_Protocols.get, > (DCMF_Request_t *) &rreq->dcmf.msg, > cb, > DCMF_MATCH_CONSISTENCY, > MPID_Request_getPeerRank(rreq), > rcvlen, > rcvbuf, > rreq->dcmf.rzvinfo.sndbuf); > } diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/pt2pt/mpid_irsend.c bgp-mpich2/src/mpid/dcmf/src/pt2pt/mpid_irsend.c 0a1,50 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file src/pt2pt/mpid_irsend.c > * \brief ADI level implemenation of MPI_Irsend() > */ > #include "mpidimpl.h" > > /** > * \brief ADI level implemenation of MPI_Irsend() > * > * \param[in] buf The buffer to send > * \param[in] count Number of elements in the buffer > * \param[in] datatype The datatype of each element > * \param[in] rank The destination rank > * \param[in] tag The message tag > * \param[in] comm Pointer to the communicator > * \param[in] context_offset Offset from the communicator context ID > * \param[out] request Return a pointer to the new request object > * > * \returns An MPI Error code > * > * Semantics of Irsend are undefined if the receiver has not posted a > * receive. We define this "undefined" behavior to look like the > * normal mode send behavior. > */ > int MPID_Irsend(const void * buf, > int count, > MPI_Datatype datatype, > int rank, > int tag, > MPID_Comm * comm, > int context_offset, > MPID_Request ** request) > { > return MPID_Isend(buf, > count, > datatype, > rank, > tag, > comm, > context_offset, > request); > } diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/pt2pt/mpid_isend.c bgp-mpich2/src/mpid/dcmf/src/pt2pt/mpid_isend.c 0a1,117 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file src/pt2pt/mpid_isend.c > * \brief ADI level implemenation of MPI_Isend() > */ > #include "mpidimpl.h" > > /** > * \brief ADI level implemenation of MPI_Isend() > * > * \param[in] buf The buffer to send > * \param[in] count Number of elements in the buffer > * \param[in] datatype The datatype of each element > * \param[in] rank The destination rank > * \param[in] tag The message tag > * \param[in] comm Pointer to the communicator > * \param[in] context_offset Offset from the communicator context ID > * \param[out] request Return a pointer to the new request object > * > * \returns An MPI Error code > * > * This is a slight variation on mpid_send.c - basically, we *always* > * want to return a send request even if the request is already > * complete (as is in the case of sending to a NULL rank). > */ > int MPID_Isend(const void * buf, > int count, > MPI_Datatype datatype, > int rank, > int tag, > MPID_Comm * comm, > int context_offset, > MPID_Request ** request) > { > MPID_Request * sreq = NULL; > > /* --------------------------- */ > /* special case: send-to-self */ > /* --------------------------- */ > > if (rank == comm->rank && comm->comm_kind != MPID_INTERCOMM) > { > /* I'm sending to myself! */ > int mpi_errno = MPIDI_Isend_self(buf, > count, > datatype, > rank, > tag, > comm, > context_offset, > MPIDI_DCMF_REQUEST_TYPE_SEND, > request); > return mpi_errno; > } > > /* --------------------- */ > /* create a send request */ > /* --------------------- */ > > if (!(sreq = MPID_SendRequest_create ())) > { > *request = NULL; > int mpi_errno = MPIR_Err_create_code(MPI_SUCCESS, > MPIR_ERR_FATAL, > "mpid_send", > __LINE__, > MPI_ERR_OTHER, > "**nomem", 0); > return mpi_errno; > } > > /* match info */ > MPID_Request_setMatch(sreq, tag,comm->rank,comm->context_id+context_offset); > > /* data buffer info */ > sreq->dcmf.userbuf = (char *)buf; > sreq->dcmf.userbufcount = count; > sreq->dcmf.datatype = datatype; > > /* communicator & destination info */ > sreq->comm = comm; MPIR_Comm_add_ref(comm); > MPID_assert(comm->vcr[rank] != NULL); > if (rank != MPI_PROC_NULL) > MPID_Request_setPeerRank(sreq, comm->vcr[rank]->lpid); > MPID_Request_setPeerRequest(sreq, sreq); > > /* message type info */ > sreq->kind = MPID_REQUEST_SEND; > MPID_Request_setType (sreq, MPIDI_DCMF_REQUEST_TYPE_SEND); > > > /* ------------------------------ */ > /* special case: NULL destination */ > /* ------------------------------ */ > if (rank == MPI_PROC_NULL) > { > MPIU_Object_set_ref(sreq, 1); > sreq->cc = 0; > *request = sreq; > return MPI_SUCCESS; > } > > /* ----------------------------------------- */ > /* start the message */ > /* ----------------------------------------- */ > > MPIDI_DCMF_StartMsg (sreq); > *request = sreq; > return MPI_SUCCESS; > } diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/pt2pt/mpid_issend.c bgp-mpich2/src/mpid/dcmf/src/pt2pt/mpid_issend.c 0a1,117 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file src/pt2pt/mpid_issend.c > * \brief ADI level implemenation of MPI_Issend() > */ > #include "mpidimpl.h" > > /** > * \brief ADI level implemenation of MPI_Issend() > * > * \param[in] buf The buffer to send > * \param[in] count Number of elements in the buffer > * \param[in] datatype The datatype of each element > * \param[in] rank The destination rank > * \param[in] tag The message tag > * \param[in] comm Pointer to the communicator > * \param[in] context_offset Offset from the communicator context ID > * \param[out] request Return a pointer to the new request object > * > * \returns An MPI Error code > * > * This is a slight variation on mpid_ssend.c - basically, we *always* > * want to return a send request even if the request is already > * complete (as is in the case of sending to a NULL rank). > */ > int MPID_Issend(const void * buf, > int count, > MPI_Datatype datatype, > int rank, > int tag, > MPID_Comm * comm, > int context_offset, > MPID_Request ** request) > { > MPID_Request * sreq = NULL; > > /* --------------------------- */ > /* special case: send-to-self */ > /* --------------------------- */ > > if (rank == comm->rank && comm->comm_kind != MPID_INTERCOMM) > { > /* I'm sending to myself! */ > int mpi_errno = MPIDI_Isend_self(buf, > count, > datatype, > rank, > tag, > comm, > context_offset, > MPIDI_DCMF_REQUEST_TYPE_SEND, > request); > return mpi_errno; > } > > /* --------------------- */ > /* create a send request */ > /* --------------------- */ > > if (!(sreq = MPID_SendRequest_create ())) > { > *request = NULL; > int mpi_errno = MPIR_Err_create_code(MPI_SUCCESS, > MPIR_ERR_FATAL, > "mpid_send", > __LINE__, > MPI_ERR_OTHER, > "**nomem", 0); > return mpi_errno; > } > > /* match info */ > MPID_Request_setMatch(sreq, tag,comm->rank,comm->context_id+context_offset); > > /* data buffer info */ > sreq->dcmf.userbuf = (char *)buf; > sreq->dcmf.userbufcount = count; > sreq->dcmf.datatype = datatype; > > /* communicator & destination info */ > sreq->comm = comm; MPIR_Comm_add_ref(comm); > MPID_assert(comm->vcr[rank] != NULL); > if (rank != MPI_PROC_NULL) > MPID_Request_setPeerRank(sreq, comm->vcr[rank]->lpid); > MPID_Request_setPeerRequest(sreq, sreq); > > /* message type info */ > sreq->kind = MPID_REQUEST_SEND; > MPID_Request_setType (sreq, MPIDI_DCMF_REQUEST_TYPE_SSEND); > MPID_Request_setSync (sreq, 1); > > /* ------------------------------ */ > /* special case: NULL destination */ > /* ------------------------------ */ > if (rank == MPI_PROC_NULL) > { > MPIU_Object_set_ref(sreq, 1); > sreq->cc = 0; > *request = sreq; > return MPI_SUCCESS; > } > > /* ----------------------------------------- */ > /* start the message */ > /* ----------------------------------------- */ > > MPIDI_DCMF_StartMsg (sreq); > *request = sreq; > return MPI_SUCCESS; > } diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/pt2pt/mpidi_startmessage.c bgp-mpich2/src/mpid/dcmf/src/pt2pt/mpidi_startmessage.c 0a1,153 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file src/pt2pt/mpidi_startmessage.c > * \brief Funnel point for starting all MPI messages > */ > #include "mpidimpl.h" > > /* ----------------------------------------------------------------------- */ > /* Helper function: gets the message underway once the request */ > /* and the buffers have been allocated. */ > /* ----------------------------------------------------------------------- */ > > static inline int > MPIDI_DCMF_Send(MPID_Request * sreq, > char * sndbuf, > unsigned sndlen) > { > int rc; > DCMF_Callback_t cb_done; > MPIDI_DCMF_MsgInfo * msginfo = &sreq->dcmf.msginfo; > MPID_assert((((unsigned) msginfo )&0x0F)==0); > MPID_assert((((unsigned) sreq )&0x0f)==0); > > if ( sndlen==0 || sndlen { > cb_done.function = (void (*)(void *))MPIDI_DCMF_SendDoneCB; > cb_done.clientdata = sreq; > > rc = DCMF_Send (&MPIDI_Protocols.send, > &sreq->dcmf.msg, > cb_done, > DCMF_MATCH_CONSISTENCY, > MPID_Request_getPeerRank(sreq), > sndlen, > sndbuf, > msginfo->quad, > 1); > } > else > { > MPIDI_DCMF_RzvEnvelope rzv_envelope; > > /* Set the isRzv bit in the SEND request. This is important for */ > /* canceling requests. */ > sreq->dcmf.msginfo.msginfo.isRzv = 1; > > /* The rendezvous information, such as the origin/local/sender */ > /* node's send buffer and the number of bytes the origin node wishes */ > /* to send, is sent as the payload of the request-to-send (RTS) */ > /* message. */ > MPIDI_DCMF_RzvInfo * rzvinfo = &sreq->dcmf.rzvinfo; > rzvinfo->sndbuf = sndbuf; > rzvinfo->sndlen = sndlen; > > MPID_assert_debug(sizeof(MPIDI_DCMF_RzvEnvelope) == 32); > memcpy(&rzv_envelope.msginfo, &sreq->dcmf.msginfo, sizeof(MPIDI_DCMF_MsgInfo)); > memcpy(&rzv_envelope.rzvinfo, &sreq->dcmf.rzvinfo, sizeof(MPIDI_DCMF_RzvInfo)); > > /* Do not specify a callback function to be invoked when the RTS */ > /* message has been sent. The MPI_Send is completed only when the */ > /* target/remote/receiver node has completed a DCMF_Get from the */ > /* origin node and has then sent a rendezvous acknowledgement (ACK) */ > /* to the origin node to signify the end of the transfer. When the */ > /* ACK message is received by the origin node the same callback */ > /* function is used to complete the MPI_Send as the non-rendezvous */ > /* case below. */ > cb_done.function = NULL; > cb_done.clientdata = NULL; > > rc = DCMF_Send (&MPIDI_Protocols.rzv, > &sreq->dcmf.msg, > cb_done, > DCMF_MATCH_CONSISTENCY, > MPID_Request_getPeerRank(sreq), > 0, > NULL, > rzv_envelope.quad, > 2); > } > > MPID_assert(rc == DCMF_SUCCESS); > return rc; > } > > /* ----------------------------------------------------------------------- */ > /* Start a message send. */ > /* ----------------------------------------------------------------------- */ > > void > MPIDI_DCMF_StartMsg (MPID_Request * sreq) > { > int data_sz, dt_contig; > MPID_Datatype *dt_ptr; > MPI_Aint dt_true_lb; > > /* ----------------------------------------- */ > /* prerequisites: not sending to a NULL rank */ > /* request already allocated */ > /* not sending to self */ > /* ----------------------------------------- */ > MPID_assert(sreq != NULL); > > /* ----------------------------------------- */ > /* get the datatype info */ > /* ----------------------------------------- */ > MPIDI_Datatype_get_info (sreq->dcmf.userbufcount, > sreq->dcmf.datatype, > dt_contig, data_sz, dt_ptr, dt_true_lb); > > /* ----------------------------------------- */ > /* contiguous data type */ > /* ----------------------------------------- */ > if (dt_contig) > { > MPID_assert(sreq->dcmf.uebuf == NULL); > MPIDI_DCMF_Send (sreq, (char *)sreq->dcmf.userbuf + dt_true_lb, data_sz); > return; > } > > /* ------------------------------------------- */ > /* allocate and populate temporary send buffer */ > /* ------------------------------------------- */ > if (sreq->dcmf.uebuf == NULL) > { > MPID_Segment segment; > > sreq->dcmf.uebuf = MPIU_Malloc(data_sz); > if (sreq->dcmf.uebuf == NULL) > { > sreq->status.MPI_ERROR = MPI_ERR_NO_SPACE; > sreq->status.count = 0; > MPID_Abort(NULL, MPI_ERR_NO_SPACE, -1, > "Unable to allocate non-contiguous buffer"); > } > > DLOOP_Offset last = data_sz; > MPID_Segment_init (sreq->dcmf.userbuf, > sreq->dcmf.userbufcount, > sreq->dcmf.datatype, > &segment,0); > MPID_Segment_pack (&segment, 0, &last, sreq->dcmf.uebuf); > MPID_assert(last == data_sz); > } > > MPIDI_DCMF_Send (sreq, sreq->dcmf.uebuf, data_sz); > } diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/pt2pt/mpid_recv.c bgp-mpich2/src/mpid/dcmf/src/pt2pt/mpid_recv.c 0a1,232 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file src/pt2pt/mpid_recv.c > * \brief ADI level implemenation of MPI_Recv() > */ > #include "mpidimpl.h" > > /** > * \brief ADI level implemenation of MPI_Recv() > * > * \param[in] buf The buffer to receive into > * \param[in] count Number of expected elements in the buffer > * \param[in] datatype The datatype of each element > * \param[in] rank The sending rank > * \param[in] tag The message tag > * \param[in] comm Pointer to the communicator > * \param[in] context_offset Offset from the communicator context ID > * \param[out] status Update the status structure > * \param[out] request Return a pointer to the new request object > * > * \returns An MPI Error code > */ > int MPID_Recv(void * buf, > int count, > MPI_Datatype datatype, > int rank, > int tag, > MPID_Comm * comm, > int context_offset, > MPI_Status * status, > MPID_Request ** request) > { > int mpi_errno = MPI_SUCCESS; > int found; > MPID_Request * rreq; > > /* ---------------------------------------- */ > /* NULL rank means nothing to do. */ > /* ---------------------------------------- */ > if (rank == MPI_PROC_NULL) > { > MPIR_Status_set_procnull(status); > *request = NULL; > > /* > * > * > * > * > * > * > * Whitespace to sync lines of code with mpidi_irecv.c > * > * > * > * > * > * > * > */ > > return MPI_SUCCESS; > } > > /* ---------------------------------------- */ > /* find our request in the unexpected queue */ > /* or allocate one in the posted queue */ > /* ---------------------------------------- */ > rreq = MPIDI_Recvq_FDU_or_AEP(rank, > tag, > comm->recvcontext_id + context_offset, > &found); > > if (rreq == NULL) > { > *request = rreq; > mpi_errno = MPIR_Err_create_code(MPI_SUCCESS, > MPIR_ERR_FATAL, > "MPID_Recv", > __LINE__, > MPI_ERR_NO_MEM, > "**nomem", > 0); > return mpi_errno; > } > > /* ----------------------------------------------------------------- */ > /* populate request with our data */ > /* We can do this because this is not a multithreaded implementation */ > /* ----------------------------------------------------------------- */ > > rreq->comm = comm; MPIR_Comm_add_ref (comm); > rreq->dcmf.userbuf = buf; > rreq->dcmf.userbufcount = count; > rreq->dcmf.datatype = datatype; > > > if (found) > { > /* ------------------------------------------------------------ */ > /* message was found in unexpected queue */ > /* ------------------------------------------------------------ */ > /* We must acknowledge synchronous send requests */ > /* The recvnew callback will acknowledge the posted messages */ > /* Recv functions will ack the messages that are unexpected */ > /* ------------------------------------------------------------ */ > > if (MPID_Request_isSelf(rreq)) > { > /* ---------------------- */ > /* "SELF" request */ > /* ---------------------- */ > MPID_Request * const sreq = rreq->partner_request; > MPID_assert(sreq != NULL); > MPIDI_DCMF_Buffer_copy(sreq->dcmf.userbuf, > sreq->dcmf.userbufcount, > sreq->dcmf.datatype, > &sreq->status.MPI_ERROR, > buf, > count, > datatype, > (MPIDI_msg_sz_t*)&rreq->status.count, > &rreq->status.MPI_ERROR); > MPID_Request_set_completed(sreq); > MPID_Request_release(sreq); > /* no other thread can possibly be waiting on rreq, > so it is safe to reset ref_count and cc */ > rreq->cc = 0; > MPIU_Object_set_ref(rreq, 1); > *request = rreq; > return rreq->status.MPI_ERROR; > } > > else if (MPID_Request_isRzv(rreq)) > { > /* -------------------------------------------------------- */ > /* Received an unexpected flow-control rendezvous RTS. */ > /* This is very similar to the found/incolplete case */ > /* -------------------------------------------------------- */ > if (HANDLE_GET_KIND(datatype) != HANDLE_KIND_BUILTIN) > { > MPID_Datatype_get_ptr(datatype, rreq->dcmf.datatype_ptr); > MPID_Datatype_add_ref(rreq->dcmf.datatype_ptr); > } > MPIDI_DCMF_RendezvousTransfer (rreq); > > *request = rreq; > return mpi_errno; > } > > else if (*rreq->cc_ptr == 0) > { > /* -------------------------------- */ > /* request is complete */ > /* if sync request, need to ack it. */ > /* -------------------------------- */ > if (MPID_Request_isSync(rreq)) > MPIDI_DCMF_postSyncAck(rreq); > > int smpi_errno; > MPID_assert(rreq->dcmf.uebuf != NULL); > if(rreq->status.cancelled == FALSE) > { > MPIDI_DCMF_Buffer_copy(rreq->dcmf.uebuf, > rreq->dcmf.uebuflen, > MPI_CHAR, > &smpi_errno, > buf, > count, > datatype, > (MPIDI_msg_sz_t*)&rreq->status.count, > &rreq->status.MPI_ERROR); > } > mpi_errno = rreq->status.MPI_ERROR; > MPIU_Free(rreq->dcmf.uebuf); rreq->dcmf.uebuf = NULL; > > if (status != MPI_STATUS_IGNORE) { *status = rreq->status; } > > MPID_Request_release(rreq); > rreq = NULL; > *request = rreq; > return mpi_errno; > } > > else > { > /* ----------------------- */ > /* request is incomplete. */ > /* ----------------------- */ > if (MPID_Request_isSync(rreq)) > MPIDI_DCMF_postSyncAck(rreq); > > if(rreq->status.cancelled == FALSE) > { > if (rreq->dcmf.uebuf) /* we have an unexpected buffer */ > rreq->dcmf.ca = MPIDI_DCMF_CA_UNPACK_UEBUF_AND_COMPLETE; > else /* no unexpected buffer; must be a resend */ > // MPIDI_DCMF_postFC (rreq, 0); /* send a NAK */ > MPID_abort(); > } > if (HANDLE_GET_KIND(datatype) != HANDLE_KIND_BUILTIN) > { > MPID_Datatype_get_ptr(datatype, rreq->dcmf.datatype_ptr); > MPID_Datatype_add_ref(rreq->dcmf.datatype_ptr); > } > *request = rreq; > return mpi_errno; > } > } > else > { > /* ----------------------------------------------------------- */ > /* request not found in unexpected queue, allocated and posted */ > /* ----------------------------------------------------------- */ > > if (HANDLE_GET_KIND(datatype) != HANDLE_KIND_BUILTIN) > { > MPID_Datatype_get_ptr(datatype, rreq->dcmf.datatype_ptr); > MPID_Datatype_add_ref(rreq->dcmf.datatype_ptr); > } > *request = rreq; > return mpi_errno; > } > return mpi_errno; > } diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/pt2pt/mpid_rsend.c bgp-mpich2/src/mpid/dcmf/src/pt2pt/mpid_rsend.c 0a1,50 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file src/pt2pt/mpid_rsend.c > * \brief ADI level implemenation of MPI_Rsend() > */ > #include "mpidimpl.h" > > /** > * \brief ADI level implemenation of MPI_Rsend() > * > * \param[in] buf The buffer to send > * \param[in] count Number of elements in the buffer > * \param[in] datatype The datatype of each element > * \param[in] rank The destination rank > * \param[in] tag The message tag > * \param[in] comm Pointer to the communicator > * \param[in] context_offset Offset from the communicator context ID > * \param[out] request Return a pointer to the new request object > * > * \returns An MPI Error code > * > * Semantics of Rsend are undefined if the receiver has not posted a > * receive. We define this "undefined" behavior to look like the > * normal mode send behavior. > */ > int MPID_Rsend(const void * buf, > int count, > MPI_Datatype datatype, > int rank, > int tag, > MPID_Comm * comm, > int context_offset, > MPID_Request ** request) > { > return MPID_Send(buf, > count, > datatype, > rank, > tag, > comm, > context_offset, > request); > } diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/pt2pt/mpid_send.c bgp-mpich2/src/mpid/dcmf/src/pt2pt/mpid_send.c 0a1,122 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file src/pt2pt/mpid_send.c > * \brief ADI level implemenation of MPI_Send() > */ > #include "mpidimpl.h" > > /** > * \brief ADI level implemenation of MPI_Send() > * > * \param[in] buf The buffer to send > * \param[in] count Number of elements in the buffer > * \param[in] datatype The datatype of each element > * \param[in] rank The destination rank > * \param[in] tag The message tag > * \param[in] comm Pointer to the communicator > * \param[in] context_offset Offset from the communicator context ID > * \param[out] request Return a pointer to the new request object > * > * \returns An MPI Error code > */ > int MPID_Send(const void * buf, > int count, > MPI_Datatype datatype, > int rank, > int tag, > MPID_Comm * comm, > int context_offset, > MPID_Request ** request) > { > MPID_Request * sreq = NULL; > > /* ------------------------------ */ > /* special case: NULL destination */ > /* ------------------------------ */ > > if (rank == MPI_PROC_NULL) > { > *request = NULL; > return MPI_SUCCESS; > } > > /* --------------------------- */ > /* special case: send-to-self */ > /* --------------------------- */ > > else if (rank == comm->rank && comm->comm_kind != MPID_INTERCOMM) > { > /* I'm sending to myself! */ > int mpi_errno = MPIDI_Isend_self(buf, > count, > datatype, > rank, > tag, > comm, > context_offset, > MPIDI_DCMF_REQUEST_TYPE_SEND, > &sreq); > if (MPIR_ThreadInfo.thread_provided <= MPI_THREAD_FUNNELED && sreq != NULL && sreq->cc != 0) > { > *request = NULL; > mpi_errno = MPIR_Err_create_code(MPI_SUCCESS, > MPIR_ERR_FATAL, > __PRETTY_FUNCTION__, > __LINE__, > MPI_ERR_OTHER, > "**dev|selfsenddeadlock", 0); > return mpi_errno; > } > *request = sreq; > return mpi_errno; > } > > /* --------------------- */ > /* create a send request */ > /* --------------------- */ > > if (!(sreq = MPID_SendRequest_create ())) > { > *request = NULL; > int mpi_errno = MPIR_Err_create_code(MPI_SUCCESS, > MPIR_ERR_FATAL, > "mpid_send", > __LINE__, > MPI_ERR_OTHER, > "**nomem", 0); > return mpi_errno; > } > > /* match info */ > MPID_Request_setMatch(sreq, tag,comm->rank,comm->context_id+context_offset); > > /* data buffer info */ > sreq->dcmf.userbuf = (char *)buf; > sreq->dcmf.userbufcount = count; > sreq->dcmf.datatype = datatype; > > /* communicator & destination info */ > sreq->comm = comm; MPIR_Comm_add_ref(comm); > MPID_Request_setPeerRank(sreq, comm->vcr[rank]->lpid); > MPID_Request_setPeerRequest(sreq, sreq); > > /* message type info */ > sreq->kind = MPID_REQUEST_SEND; > MPID_Request_setType (sreq, MPIDI_DCMF_REQUEST_TYPE_SEND); > > > /* ----------------------------------------- */ > /* start the message */ > /* ----------------------------------------- */ > > MPIDI_DCMF_StartMsg (sreq); > *request = sreq; > return MPI_SUCCESS; > } diff -rN mpich2-1.0.7rc1/src/mpid/dcmf/src/pt2pt/mpid_ssend.c bgp-mpich2/src/mpid/dcmf/src/pt2pt/mpid_ssend.c 0a1,122 > /* begin_generated_IBM_copyright_prolog */ > /* */ > /* ---------------------------------------------------------------- */ > /* (C)Copyright IBM Corp. 2007, 2008 */ > /* IBM CPL License */ > /* ---------------------------------------------------------------- */ > /* */ > /* end_generated_IBM_copyright_prolog */ > /** > * \file src/pt2pt/mpid_ssend.c > * \brief ADI level implemenation of MPI_Ssend() > */ > #include "mpidimpl.h" > > /** > * \brief ADI level implemenation of MPI_Ssend() > * > * \param[in] buf The buffer to send > * \param[in] count Number of elements in the buffer > * \param[in] datatype The datatype of each element > * \param[in] rank The destination rank > * \param[in] tag The message tag > * \param[in] comm Pointer to the communicator > * \param[in] context_offset Offset from the communicator context ID > * \param[out] request Return a pointer to the new request object > * > * \returns An MPI Error code > */ > int MPID_Ssend(const void * buf, > int count, > MPI_Datatype datatype, > int rank, > int tag, > MPID_Comm * comm, > int context_offset, > MPID_Request ** request) > { > MPID_Request * sreq = NULL; > > /* ------------------------------ */ > /* special case: NULL destination */ > /* ------------------------------ */ > > if (rank == MPI_PROC_NULL) > { > *request = NULL; > return MPI_SUCCESS; > } > > /* --------------------------- */ > /* special case: send-to-self */ > /* --------------------------- */ > > else if (rank == comm->rank && comm->comm_kind != MPID_INTERCOMM) > { > /* I'm sending to myself! */ > int mpi_errno = MPIDI_Isend_self(buf, > count, > datatype, > rank, > tag, > comm, > context_offset, > MPIDI_DCMF_REQUEST_TYPE_SEND, > &sreq); > if (MPIR_ThreadInfo.thread_provided <= MPI_THREAD_FUNNELED && sreq != NULL && sreq->cc != 0) > { > *request = NULL; > mpi_errno = MPIR_Err_create_code(MPI_SUCCESS, > MPIR_ERR_FATAL, > __PRETTY_FUNCTION__, > __LINE__, > MPI_ERR_OTHER, > "**dev|selfsenddeadlock", 0); > return mpi_errno; > } > *request = sreq; > return mpi_errno; > } > > /* --------------------- */ > /* create a send request */ > /* --------------------- */ > > if (!(sreq = MPID_SendRequest_create ())) > { > *request = NULL; > int mpi_errno = MPIR_Err_create_code(MPI_SUCCESS, > MPIR_ERR_FATAL, > "mpid_send", > __LINE__, > MPI_ERR_OTHER, > "**nomem", 0); > return mpi_errno; > } > > /* match info */ > MPID_Request_setMatch(sreq, tag,comm->rank,comm->context_id+context_offset); > > /* data buffer info */ > sreq->dcmf.userbuf = (char *)buf; > sreq->dcmf.userbufcount = count; > sreq->dcmf.datatype = datatype; > > /* communicator & destination info */ > sreq->comm = comm; MPIR_Comm_add_ref(comm); > MPID_Request_setPeerRank(sreq, comm->vcr[rank]->lpid); > MPID_Request_setPeerRequest(sreq, sreq); > > /* message type info */ > sreq->kind = MPID_REQUEST_SEND; > MPID_Request_setType (sreq, MPIDI_DCMF_REQUEST_TYPE_SSEND); > MPID_Request_setSync (sreq, 1); > > /* ----------------------------------------- */ > /* start the message */ > /* ----------------------------------------- */ > > MPIDI_DCMF_StartMsg (sreq); > *request = sreq; > return MPI_SUCCESS; > } diff -rN mpich2-1.0.7rc1/src/mpid/Makefile.sm bgp-mpich2/src/mpid/Makefile.sm 2c2 < SUBDIRS_device_name = ch3 globus --- > SUBDIRS_device_name = ch3 globus dcmf diff -rN mpich2-1.0.7rc1/test/iotestlist bgp-mpich2/test/iotestlist 0a1 > mpi diff -rN mpich2-1.0.7rc1/test/long.xsl bgp-mpich2/test/long.xsl 0a1,63 > > > > > > > > > MPICH Error Report > > >

Error Report

> > >
> > > > > > > > > > > Test run on > > > > > > > > > > > > > > > 
>     
>
> > > 
>     
>
> > > > > > > > > > Traceback > > > > > diff -rN mpich2-1.0.7rc1/test/Makefile.sm bgp-mpich2/test/Makefile.sm 7c7,9 < # Test both the MPI routines and the MPICH2 command scripts --- > testingio: > (cd mpi && $(MAKE) testingio) > 9,12c11,25 < (NOXMLCLOSE=YES && export NOXMLCLOSE && cd mpi && $(MAKE) testing) < (XMLFILE=../mpi/summary.xml && XMLCONTINUE=YES && \ < export XMLFILE && export XMLCONTINUE && \ < cd commands && $(MAKE) testing) --- > (cd mpi && $(MAKE) testing) > > testingvnm: > (cd mpi && $(MAKE) testingvnm) > > testing-mpirun: > (cd mpi && $(MAKE) testing-mpirun) > testingvnm-mpirun: > (cd mpi && $(MAKE) testingvnm-mpirun) > testingio-mpirun: > (cd mpi && $(MAKE) testingio-mpirun) > > testingdual-mpirun: > (cd mpi && $(MAKE) testingdual-mpirun) > diff -rN mpich2-1.0.7rc1/test/mpi/cxx/io/ioharness.tlt bgp-mpich2/test/mpi/cxx/io/ioharness.tlt 43c43 < 1,4000, 4000,8, 4096,8, 64000,8, 65536,8 }; --- > 1,40, 4000,8, 4096,8, 64000,8, 65536,8 }; diff -rN mpich2-1.0.7rc1/test/mpi/cxx/io/iotestlist bgp-mpich2/test/mpi/cxx/io/iotestlist 0a1,28 > iwriteat 4 > iwrite 4 > iwritesh 4 > write 4 > writeat 4 > writeall 4 > writesh 4 > writeord 4 > writeatall 4 > writeatallbe 4 > writeallbe 4 > writeordbe 4 > iwriteatnos 4 > iwritenos 4 > iwriteshnos 4 > writenos 4 > writeatnos 4 > writeallnos 4 > writeshnos 4 > writeordnos 4 > writeatallnos 4 > writeatallbenos 4 > writeallbenos 4 > writeordbenos 4 > fileerrx 1 > fileinfox 3 > filemiscx 4 > shpositionx 4 diff -rN mpich2-1.0.7rc1/test/mpi/cxx/iotestlist bgp-mpich2/test/mpi/cxx/iotestlist 0a1 > io diff -rN mpich2-1.0.7rc1/test/mpi/errors/coll/rerr.c bgp-mpich2/test/mpi/errors/coll/rerr.c 31,34c31,34 < if (verbose) { < MPI_Error_string( ierr, str, &slen ); < printf( "Found expected error; message is: %s\n", str ); < } --- > /* if (verbose) { */ > /* MPI_Error_string( ierr, str, &slen ); */ > /* printf( "Found expected error; message is: %s\n", str ); */ > /* } */ diff -rN mpich2-1.0.7rc1/test/mpi/f77/io/ioharness.tlt bgp-mpich2/test/mpi/f77/io/ioharness.tlt 19,20c19,20 < < data fparms/1,4000, 4000,8, 4096,8, 64000,8, 65536,8 / --- > > data fparms/1,40, 4000,8, 4096,8, 64000,8, 65536,8 / diff -rN mpich2-1.0.7rc1/test/mpi/f77/io/iotestlist bgp-mpich2/test/mpi/f77/io/iotestlist 0a1,18 > iwriteatf 8 > iwritef 8 > iwriteshf 8 > writef 8 > writeatf 8 > writeallf 8 > writeshf 8 > writeordf 8 > writeatallf 8 > writeatallbef 8 > writeallbef 8 > writeordbef 8 > fileerrf 1 > fileinfof 3 > shpositionf 4 > atomicityf 8 > miscfilef 4 > diff -rN mpich2-1.0.7rc1/test/mpi/f77/io/shpositionf.f bgp-mpich2/test/mpi/f77/io/shpositionf.f 34,35c34,37 < call mpi_file_get_type_extent( fh, MPI_INTEGER, aint, ierr ) < fileintsize = aint --- > ! call mpi_file_get_type_extent( fh, MPI_INTEGER, offset, ierr ) > ! fileintsize = offset > call mpi_file_get_type_extent( fh, MPI_INTEGER, > & fileintsize, ierr ) diff -rN mpich2-1.0.7rc1/test/mpi/f77/iotestlist bgp-mpich2/test/mpi/f77/iotestlist 0a1 > io diff -rN mpich2-1.0.7rc1/test/mpi/init/testlist bgp-mpich2/test/mpi/init/testlist 1,2c1,2 < exitst1 2 resultTest=TestStatus < exitst2 4 resultTest=TestStatus --- > #exitst1 2 resultTest=TestStatus # temp disable until fixed. issue 7051 > #exitst2 4 resultTest=TestStatus # temp disable until fixed. issue 7051 4c4 < timeout 2 resultTest=TestTimeout timeLimit=10 --- > #timeout 2 resultTest=TestTimeout timeLimit=10 # temp disable until fixed. issue 7051 diff -rN mpich2-1.0.7rc1/test/mpi/io/iotestlist bgp-mpich2/test/mpi/io/iotestlist 0a1,8 > rdwrord 8 > rdwrzero 8 > getextent 2 > setinfo 8 > setviewcur 8 > i_noncontig 2 > async 8 > async_any 8 diff -rN mpich2-1.0.7rc1/test/mpi/iotestlist bgp-mpich2/test/mpi/iotestlist 0a1,3 > io > # f77 > # cxx diff -rN mpich2-1.0.7rc1/test/mpi/Makefile.sm bgp-mpich2/test/mpi/Makefile.sm 3a4,40 > ROPTS = > > # This target is like the "testing*" ones, except that it has > # the following format: > # > # "testrun"[][_