ports/openmpi
ports/openmpi
1
1
Форкнуть 0
Код Релизы Активность
openmpi/ompi/mca/io/romio/romio-dist/configure2.in
Jeff Squyres 4ab17f019b Rename src -> ompi 
This commit was SVN r6269.
2005-07-02 13:43:57 +00:00

1345 строки
40 KiB
Plaintext
Исходник Ответственный История

# build with
# autoconf -output=configure2 --localdir=../confdb configure2.in
# (or wherever the confdb is)
# The following usage message is out-of-date
# It is retained only to remind us which options were defined.
usage_msg="
Usage: ${progname} [-file_system=FILE_SYSTEM] [-arch=ARCH_TYPE] [-mpi=MPI_IMPL]
[-mpiincdir=MPI_INCLUDE_DIR] [-mpilib=MPI_LIBRARY]
[-mpibindir=MPI_BIN_DIR]
[-cc=C_COMPILER] [-fc=FORTRAN_COMPILER] [-nof77]
[-cflags=CFLAGS] [-fflags=FFLAGS] [-f90=F90_COMPILER] [-debug]
[-make=MAKEPGM] [-mpiolib=MPIO_LIBRARY] [-ar_nolocal]
[-noranlib] [-ar=AR_COMMAND] [-prefix=INSTALL_DIR]
[-intsize=INTSIZE] [-ptrsize=PTRSIZE] [-longsize=LONGSIZE]
[-longlongsize=LONGLONGSIZE] [-f90nag] [-disable-weak-symbols]
where
FILE_SYSTEM = the file system(s) for which ROMIO is to be configured.
Valid values are pfs, piofs, hfs, xfs, sfs, pvfs, ufs,
and nfs (case-sensitive). They correspond to Intel's PFS,
IBM's PIOFS, HP/Convex's HFS, SGI's XFS, NEC's SFS,
Clemson University's PVFS (for Linux clusters), any Unix
file system, and NFS.
To configure for multiple file systems, use "+" as a
separator; e.g., ufs+nfs
ARCH_TYPE = the type of machine for which ROMIO is to be configured.
Not needed on most machines, because ROMIO can usually
find the arch_type on its own. Needed if you are
cross-compiling for a different architecture.
Valid values are sun4, solaris, solaris86, rs6000,
paragon, hpux, sppux, IRIX, IRIX32, IRIXN32, IRIX64, SX4,
alpha, freebsd, LINUX, and LINUX_ALPHA. (case-sensitive)
MPI_IMPL = the MPI implementation with which ROMIO will be used
Valid values are mpich, sgi, hp. (case-sensitive)
Valid implementations are MPICH 1.1.1 or higher,
SGI's MPI 3.1 or higher, HP MPI 1.3 or higher, LAM,
and Cray MPI.
MPI_INCLUDE_DIR = the full path of the directory where mpi.h is located.
Not needed if the directory is in the compiler's
default include path
MPI_LIBRARY = name of the file containing the MPI library (full path).
Not needed if the library is in the compiler's default
list of libraries
MPI_BIN_DIR = the full path of the directory that contains the MPI
versions of the compilers, such as mpicc and mpif77.
Use only if the ROMIO configure cannot find the
necessary commands
C_COMPILER = the C compiler to use. If not specified, ROMIO uses a
default compiler depending on the machine.
FORTRAN_COMPILER = the Fortran compiler to use. If not specified, ROMIO
uses a default compiler depending on the machine.
CFLAGS = flags to give to the C compiler
FFLAGS = flags to give to the Fortran compiler
F90_COMPILER = the Fortran 90 compiler to use. If not specified,
ROMIO uses f90.
MPIO_LIBRARY = name of the MPI-IO library to be built (full path).
Default is "this_directory"/lib/ARCH_TYPE/libmpio.a.
MAKEPGM = name of the make program to use
AR_COMMAND = an alternate archiver (ar) command to use.
INSTALL_DIR = directory where ROMIO is to be installed
INTSIZE = size of int in bytes.
PTRSIZE = size of pointers in bytes.
LONGSIZE = size of long in bytes.
LONGLONGSIZE = size of long long in bytes.
The options '-mpiincdir' and '-mpilib' may be needed if the MPI include file
and MPI library are not in the compiler's default path.
The option '-nof77' prevents the compilation of routines that require a
Fortran compiler. If you select this option, you cannot use the
Fortran interface of MPI-IO.
The option '-f90nag' allows you to use the NAG Fortran 90 compiler
instead of Fortran 77.
The option '-make' may be used to select an alternate make program. ROMIO
uses "make" by default.
If '-debug' is used, ROMIO will be configured with the '-g' compiler option
for debugging.
The option '-ar_nolocal' prevents the library archive command from
attempting to use the local directory for temporary space. This option
should be used when (a) there isn't much space (less than 10 MB)
available in the partition where ROMIO resides and (b) there is enough
space in /tmp (or wherever ar places temporary files by default).
The option '-noranlib' causes the 'ranlib' step (needed on some systems
to build an object library) to be skipped. This is particularly useful
on systems where 'ranlib' is optional (allowed but not needed; because it
is allowed, configure chooses to use it just in case) but can fail (some
'ranlib's are implemented as scripts using 'ar'; if they don't use the
local directory, they can fail (destroying the library in the process) if
the temporary directory (usually '/tmp') does not have enough space.
The option -disable-weak-symbols disables the use of weak symbols, even if
available, for building the profiling interface.
"
#
AC_INIT(adio/include/romioconf.h.in)
echo " "
echo "Configuring ROMIO Version 1.2.3"
echo " "
CONFIGURE_ARGS="$*"
if test -n "$CONFIGURE_ARGS" ; then
echo "Configuring with args $CONFIGURE_ARGS"
fi
AC_CONFIG_HEADER(adio/include/romioconf.h)
dnl
NOF77=0
ARCH=""
arch_IRIX=""
MPI=""
MPI_INCLUDE_DIR=""
ROMIO_INCLUDE=""
MPI_LIB=""
LIBNAME=""
TEST_LIBNAME=""
FILE_SYSTEM=""
DEBUG=no
MIPS=0
BITS=0
FROM_MPICH=${FROM_MPICH:-0}
FROM_MPICH2=${FROM_MPICH2:-0}
CFLAGS=${CFLAGS:-""}
LL="\%lld"
AR_LOCAL=l
HAVE_MPI_INFO=""
BUILD_MPI_INFO=""
MPI_FINFO1=""
MPI_FINFO2=""
MPI_FINFO3=""
MPI_FINFO4=""
MPI_FARRAY1=""
MPI_FARRAY2=""
MPI_FARRAY3=""
MPI_FARRAY4=""
MPI_FARRAY5=""
MPI_FARRAY6=""
MPI_FARRAY7=""
DEFS=""
ROMIO_LFLAGS=""
ROMIO_LIBLIST=""
ROMIO_TCFLAGS=""
ROMIO_TCPPFLAGS=""
ROMIO_TFFLAGS=""
NOPROFILE=0
MPIRUN=""
FORTRAN_TEST=""
MAKE=${MAKE:-"make"}
# foll. needed for f77 test programs
F77GETARG="call getarg(i,str)"
F77IARGC="iargc()"
FTESTDEFINE=""
FORTRAN_MPI_OFFSET=""
MPIOF_H_INCLUDED=0
MPI_OFFSET_KIND1="!"
MPI_OFFSET_KIND2="!"
F90=""
TEST_CC=""
TEST_F77=""
TRY_WEAK_SYMBOLS=1
#
known_filesystems="nfs ufs pfs piofs pvfs testfs xfs hfs sfs"
known_mpi_impls="mpich_mpi sgi_mpi hp_mpi cray_mpi lam_mpi"
#
# Defaults
AC_ARG_ENABLE(aio,[
--enable-aio - Request use of asynchronous I/O routines],,enable_aio=notgiven)
AC_ARG_ENABLE(echo,
[--enable-echo - Turn on strong echoing. The default is enable=no.] ,set -x)
AC_ARG_ENABLE(f77,
[--enable-f77 - Turn on support for Fortran 77 (default)],,enable_f77=yes)
AC_ARG_WITH(file-system,[
--with-file-system=name - Build with support for the named file systems],,)
AC_ARG_WITH(mpi,[
--with-mpi=name - Specify MPI implementation to build ROMIO for],,)
dnl
if test "$enable_f77" != "yes" ; then
NOF77=1
fi
MPI=$with_mpi
FILE_SYSTEM=$with_file_system
#
for arg
do
case $arg in
-arch=* | --arch=*)
ARCH=`echo $arg|sed 's/-*arch=//'`
eval "arch_`echo $ARCH`=1"
;;
-debug | --debug | --enable-g | -enable-g)
echo "Configuring for a debugging version"
DEBUG=yes
;;
-from_mpich | --from_mpich)
FROM_MPICH=1
;;
-noprofile | --noprofile | --disable-profile | -disable-profile )
echo "profiling interface will not be built"
NOPROFILE=1
;;
-disable-weak-symbols|--disable-weak-symbols)
TRY_WEAK_SYMBOLS=0
;;
esac
done
#
AC_CONFIG_AUX_DIR(../../../confdb)
dnl PAC_ARG_CACHING
rm -f config.log
#
# Check that an arch was set
# If it wasn't set, try to guess using "util/tarch"
#
if test -z "$ARCH" -a -x $srcdir/util/tarch ; then
AC_MSG_CHECKING(for architecture)
ARCH=`$srcdir/util/tarch | sed s/-/_/g`
if test -z "$ARCH" ; then
AC_MSG_RESULT(Unknown!)
AC_MSG_ERROR([Error: Couldn't guess target architecture, you must
set an architecture type with -arch=<value>])
fi
eval "arch_$ARCH=1"
AC_MSG_RESULT($ARCH)
fi
#
# check for valid architecture. Use __ so that _ALPHA_ does not match
# LINUX_ALPHA_
#### WE SHOULD REMOVE THIS SOON
grep __"$ARCH"_ $srcdir/.config_params > /dev/null 2>&1
if test $? != 0 ; then
AC_MSG_WARN([Unknown architecture $arch... proceeding anyway])
fi
#
#
#
# Find the home directory if not specified
if test "X$srcdir" != "X." -a -s $srcdir/mpi-io/Makefile.in ; then
ROMIO_HOME_TRIAL=$srcdir
else
PAC_GETWD(ROMIO_HOME_TRIAL,mpi-io/Makefile.in)
fi
echo "ROMIO home directory is $ROMIO_HOME_TRIAL"
ROMIO_HOME=$ROMIO_HOME_TRIAL
#
# Create the "autoconf" style directory names...
#
# mandir is the root for the man pages
if test -z "$mandir" ; then mandir='${prefix}/man' ; fi
AC_SUBST(mandir)
if test -z "$docdir" ; then docdir='${prefix}/doc' ; fi
AC_SUBST(docdir)
if test -z "$htmldir" ; then htmldir='${prefix}/www' ; fi
AC_SUBST(htmldir)
#
# check for valid file system
if test -n "$FILE_SYSTEM" ; then
# if multiple filesystems are passed in, they are '+'-delimited
# we could set the IFS to tokenize FILE_SYSTEM, but the FILE_SYSTEM env var
# is used in multiple places in the build system: get rid of the '+'s so we
# can use the 'for x in $FILE_SYSTEM ...' idiom
FILE_SYSTEM=`echo $FILE_SYSTEM|sed -e 's/\+/ /g'`
for x in $FILE_SYSTEM
do
found=no
for y in $known_filesystems ; do
if test $x = $y ; then
found=yes
eval "file_system_`echo $x`=1"
break
fi
done
if test "$found" = "no" ; then
AC_MSG_WARN([Unknown file system $x... proceeding anyway])
fi
done
fi
#
# check for valid MPI implementation
if test -n "$MPI" ; then
found=no
for mpi in $known_mpi_impls ; do
if test "${MPI}_mpi" = "$mpi" ; then
found=yes
break
fi
done
if test $found = no ; then
AC_MSG_WARN([Unknown MPI implementation $MPI... proceeding anyway])
fi
fi
#
# check for valid MPI include directory if specified
if test $FROM_MPICH = 0 -a $FROM_MPICH2 = 0 ; then
if test -n "$MPI_INCLUDE_DIR"; then
if test ! -f "$MPI_INCLUDE_DIR/mpi.h" ; then
AC_MSG_ERROR([Include file $MPI_INCLUDE_DIR/mpi.h not found])
fi
else
# assume that mpi.h is in the default path
# set MPI_INCLUDE_DIR to ".", so that it translates to -I. in the
# compile command. Some compilers complain if it's only -I
MPI_INCLUDE_DIR=.
fi
else
MPI_INCLUDE_DIR=.
fi
#
# check for valid MPI library if specified
if test $FROM_MPICH = 0 -a $FROM_MPICH2 = 0 ; then
if test -n "$MPI_LIB" ; then
if test ! -f "$MPI_LIB" ; then
AC_MSG_ERROR([MPI library $MPI_LIB not found])
fi
fi
fi
#
#
AR="${AR:-ar} cr$AR_LOCAL"
if test -z "$RANLIB" ; then
AC_PROG_RANLIB
fi
MAKE=${MAKE:-make}
#
# USER_CFLAGS and USER_FFLAGS are used only in test/Makefile.in
if test $DEBUG = "yes"; then
USER_CFLAGS="$CFLAGS -g"
USER_FFLAGS="$FFLAGS -g"
else
USER_CFLAGS="$CFLAGS -O"
USER_FFLAGS="$FFLAGS -O"
fi
#
if test -n "$arch_sun4" ; then
CC=${CC:-gcc}
F77=${FC:-f77}
if test $DEBUG = "yes"; then
if test "$CC" = "gcc"; then
CFLAGS="$CFLAGS -g -O -Wall -Wstrict-prototypes -Wmissing-prototypes"
else
CFLAGS="$CFLAGS -g"
fi
else
CFLAGS="$CFLAGS -O"
fi
if test "$enable_aio" = "no" ; then
AC_DEFINE(NO_AIO,,[Define if AIO should not be used])
else
AC_DEFINE(AIO_SUN,,[Define for SUN0S 4])
fi
if test -z "$MPI" ; then
MPI=mpich
mpi_mpich=1
fi
if test -z "$FILE_SYSTEM" ; then
file_system_ufs=1
file_system_nfs=1
FILE_SYSTEM="ufs nfs"
AC_MSG_RESULT([configuring for file systems ufs and nfs])
fi
fi
#
if test -n "$arch_solaris" || test -n "$arch_solaris86" ; then
CC=${CC:-cc}
F77=${FC:-f77}
if test $DEBUG = "yes"; then
if test "$CC" = "gcc" ; then
CFLAGS="$CFLAGS -g -O -Wall -Wstrict-prototypes -Wmissing-prototypes"
else
CFLAGS="$CFLAGS -g -v"
fi
else
CFLAGS="$CFLAGS -O"
fi
if test "$enable_aio" = "no" ; then
AC_DEFINE(NO_AIO,,[Define if AIO should not be used])
else
AC_DEFINE(AIO_SUN,,[Define for SUN0S 4])
fi
if test -z "$MPI" ; then
MPI=mpich
mpi_mpich=1
fi
if test -z "$FILE_SYSTEM" ; then
file_system_ufs=1
file_system_nfs=1
FILE_SYSTEM="ufs nfs"
AC_MSG_RESULT([configuring for file systems ufs and nfs])
fi
AC_DEFINE(SOLARIS,,[Define for Solaris])
if test $MPI = "mpich" ; then
TEST_CC=mpicc
TEST_F77=mpif77
else
TEST_CC="$CC"
TEST_F77="$F77"
fi
if test "$enable_aio" != "no" ; then
MPI_LIB="$MPI_LIB -laio"
ROMIO_LIBLIST="-laio"
fi
AR="ar cr"
# solaris does not have l option to ar
# solaris f90 does not have 8-byte integer type
# (it does now!!!! 11/29/01)
fi
#
if test -n "$arch_rs6000"; then
F77=$FC
if test -z "$CC"; then
AC_PROGRAMS_CHECK(CC, mpcc, cc)
echo "Using $CC"
fi
if test $NOF77 = 0 && test -z "$FC"; then
AC_PROGRAMS_CHECK(F77, mpxlf, f77)
echo "Using $F77"
fi
if test $DEBUG = "yes"; then
CFLAGS="$CFLAGS -g"
else
CFLAGS="$CFLAGS -O"
fi
# Check that aio is available (many systems appear to have aio
# either installed improperly or turned off).
# The test is the following: if not cross compiling, try to run a
# program that includes a *reference* to aio_write but does not call it
# If the libraries are not set up correctly, then this will fail.
AC_MSG_CHECKING([whether aio routines can be used])
AC_TRY_RUN([
int main( int argc, char **argv )
{
if (argc > 10) aio_write();
return 0;
}
],aio_runs=yes,aio_runs=no,aio_runs=unknown)
AC_MSG_RESULT($aio_runs)
if test "$enable_aio" != "no" -a "$aio_runs" = "no" ; then
enable_aio=no
fi
if test "$enable_aio" = "no" ; then
AC_DEFINE(NO_AIO,,[Define if AIO should not be used])
else
AC_DEFINE(NO_FD_IN_AIOCB,,[Define for no fd in the aiocb])
AC_DEFINE(AIO_HANDLE_IN_AIOCB,,[Define for aio handle in aiocb])
fi
if test -z "$MPI" ; then
MPI=mpich
mpi_mpich=1
fi
if test -z "$FILE_SYSTEM" ; then
if test "$CC" = "mpcc" || test "$CC" = "mpCC" ; then
file_system_piofs=1
FILE_SYSTEM="piofs"
AC_MSG_RESULT([configuring for file systems piofs, ufs, and nfs])
else
AC_MSG_RESULT([configuring for file systems ufs and nfs])
fi
file_system_ufs=1
file_system_nfs=1
FILE_SYSTEM="$FILE_SYSTEM ufs nfs"
fi
AC_DEFINE(AIX,,[Define for AIX])
# assume long long exists.
longlongsize=${longlongsize:-8}
MPI_OFFSET_KIND1=" INTEGER MPI_OFFSET_KIND"
MPI_OFFSET_KIND2=" PARAMETER (MPI_OFFSET_KIND=8)"
fi
#
if test -n "$arch_paragon"; then
CC=${CC:-icc}
F77=${FC:-if77}
if test $DEBUG = "yes"; then
CFLAGS="$CFLAGS -g"
else
if test "$CC" = "icc"; then
CFLAGS="$CFLAGS -Knoieee -Mvect -O3"
else
CFLAGS="$CFLAGS -O"
fi
fi
AR="ar860 cr$AR_LOCAL"
MPI_LIB="$MPI_LIB -nx"
if test -z "$MPI" ; then
MPI=mpich
mpi_mpich=1
fi
if test -z "$FILE_SYSTEM" ; then
file_system_pfs=1
file_system_ufs=1
file_system_nfs=1
FILE_SYSTEM="pfs ufs nfs"
AC_MSG_RESULT([configuring for file systems pfs, ufs, and nfs])
fi
AC_DEFINE(PARAGON,,[Define for Intel Paragon])
AC_DEFINE(NO_AIO,,[Define if AIO should not be used])
# NO_AIO is if configuring for NFS/UFS. It doesn't affect PFS asynch. I/O.
# long long does not exist
longlongsize=${longlongsize:-0}
fi
#
if test -n "$arch_tflop" || test -n "$arch_tflops"; then
CC=${CC:-pgcc}
F77=${FC:-pgf77}
TFLOP_FLAGS="-cougar -D__PUMA"
AC_DEFINE(NO_AIO,,[Define if AIO should not be used])
if test $DEBUG = "yes"; then
CFLAGS="$CFLAGS -g $TFLOP_FLAGS"
else
if test "$CC" = "pgcc"; then
CFLAGS="$CFLAGS -Knoieee -Mvect -O3 $TFLOP_FLAGS"
else
CFLAGS="$CFLAGS -O $TFLOP_FLAGS"
fi
fi
AR="xar cr$AR_LOCAL"
RANLIB="xranlib"
MPI_LIB="$MPI_LIB"
if test -z "$MPI" ; then
MPI=mpich
mpi_mpich=1
fi
if test -z "$FILE_SYSTEM" ; then
file_system_ufs=1
FILE_SYSTEM="ufs"
AC_MSG_RESULT([configuring for file system ufs])
fi
fi
#
if test -n "$arch_freebsd" || test -n "$arch_LINUX" || test -n "$arch_LINUX_ALPHA" || test -n "$arch_netbsd" || test -n "$arch_openbsd" ; then
CC=${CC:-gcc}
if test -n "$arch_freebsd" || test -n "$arch_netbsd" || test -n "$arch_openbsd"; then
F77=${FC:-f77}
AC_DEFINE(FREEBSD,,[Define for FreeBSD])
PAC_HAVE_MOUNT_NFS
longlongsize=${longlongsize:-0}
# printf doesn't work properly and no integer*8 as far as I can tell
else
F77=${FC:-g77}
AC_DEFINE(LINUX,,[Define for Linux])
fi
if test $DEBUG = "yes" ; then
if test "$CC" = "gcc" ; then
CFLAGS="$CFLAGS -g -O -Wall -Wstrict-prototypes -Wmissing-prototypes"
else
CFLAGS="$CFLAGS -g"
fi
else
CFLAGS="$CFLAGS -O"
fi
if test "$enable_aio" != "yes" ; then
AC_DEFINE(NO_AIO,,[Define if AIO should not be used])
else
# Try to find the aio routines
use_aio=no
AC_HEADER_CHECK(aio.h,has_aio_h=yes,has_aio_h=no)
add_lib=""
AC_SEARCH_LIBS(aio_write,aio,add_lib="-laio")
# What function do we want -lrt for?
AC_HAVE_LIBRARY(rt,add_lib="$add_lib -lrt")
AC_SEARCH_LIBS(pthread_create,pthread,[add_lib="$add_lib -lpthread"
has_pthread=yes],[has_pthread=no])
AC_FUNC_CHECK(aio_write,has_aio_write=yes,has_aio_write=no)
if test "$has_aio_h" = "yes" -a "$has_aio_write" = "yes" -a \
"$has_pthread" = "yes" ; then
use_aio=yes
fi
# Check for aiocb_t as a shorthand for struct aiocb
AC_MSG_CHECKING([for aiocb_t])
AC_TRY_COMPILE([#include <aio.h>],
[aiocb_t a;],has_aiocb_t=yes,has_aiocb_t=no)
AC_MSG_RESULT($has_aiocb_t)
if test "$has_aiocb_t" = "no" ; then
AC_DEFINE(NEEDS_AIOCB_T,,[Define for aiocb_t definition needed])
fi
if test "$use_aio" = "yes" ; then
MPI_LIB="$MPI_LIB $add_lib"
ROMIO_LIBLIST="$ROMIO_LIBLIST $add_lib"
else
AC_DEFINE(NO_AIO,,[Define if AIO should not be used])
fi
fi
if test -z "$MPI" ; then
MPI=mpich
mpi_mpich=1
fi
if test -z "$FILE_SYSTEM" ; then
file_system_ufs=1
file_system_nfs=1
FILE_SYSTEM="ufs nfs"
AC_MSG_RESULT([configuring for file systems ufs and nfs])
fi
fi
#
if test -n "$arch_SX4" ; then
CC=${CC:-mpicc}
F77=${FC:-mpif90}
if test $DEBUG = "yes" ; then
CFLAGS="$CFLAGS -g"
FFLAGS="$FFLAGS -g"
else
USER_FFLAGS="$FFLAGS -Chopt"
CFLAGS="$CFLAGS -O"
FFLAGS="$FFLAGS -Chopt"
fi
AC_DEFINE(NO_AIO,,[Define if AIO should not be used])
AC_DEFINE(SX4,,[Define for NEC SX4])
if test -z "$MPI" ; then
MPI=mpich
mpi_mpich=1
fi
if test -z "$FILE_SYSTEM" ; then
file_system_sfs=1
file_system_nfs=1
FILE_SYSTEM="sfs nfs"
AC_MSG_RESULT([configuring for file systems sfs and nfs])
fi
MPI_OFFSET_KIND1=" INTEGER MPI_OFFSET_KIND"
MPI_OFFSET_KIND2=" PARAMETER (MPI_OFFSET_KIND=8)"
fi
#
if test -n "$arch_hpux" || test -n "$arch_sppux" ; then
if test $DEBUG = "yes"; then
CFLAGS="$CFLAGS -g +w1"
else
CFLAGS="$CFLAGS -O"
fi
AC_DEFINE(NO_AIO,,[Define if AIO should not be used])
RANLIB=":"
if test -z "$MPI"; then
if test -f "/opt/mpi/include/mpi.h" ; then
echo "assuming that you want to use ROMIO with HP MPI"
MPI=hp
else
echo "assuming that you want to use ROMIO with MPICH"
MPI=mpich
fi
fi
if test $MPI = "mpich" ; then
mpi_mpich=1
MPI_LIB="$MPI_LIB -lV3"
CC=${CC:-cc -Ae}
F77=${FC:-f77 +U77}
fi
if test $MPI = "hp" ; then
mpi_hp=1
CC=${CC:-mpicc -Ae}
F77=${FC:-mpif77 +U77}
fi
if test $MPI = "lam" && test "$FC" != ""; then
FC="$FC +U77"
fi
FTESTDEFINE="external iargc, getarg"
if test -n "$arch_hpux" ; then
CFLAGS="$CFLAGS -D_LARGEFILE64_SOURCE"
AC_DEFINE(HPUX,,[Define for HPUX])
if test $MPI = "hp" ; then
F77=${FC:-mpif90 +U77}
else
F77=${FC:-f90 +U77}
fi
else
AC_DEFINE(SPPUX,,[Define for SPPUX (Convex)])
fi
if test -z "$FILE_SYSTEM" ; then
if test -n "$arch_hpux" ; then
AC_MSG_CHECKING([for struct flock64])
AC_TRY_COMPILE([#include <fcntl.h>],[
struct flock64 fl; int i=F_SETLKW64;],flock64_ok="yes",flock64_ok="no")
AC_MSG_RESULT($flock64_ok)
else
flock64_ok="yes"
fi
if test $flock64_ok = "yes" ; then
file_system_hfs=1
file_system_nfs=1
FILE_SYSTEM="hfs nfs"
AC_MSG_RESULT([configuring for file systems hfs and nfs])
else
file_system_ufs=1
file_system_nfs=1
FILE_SYSTEM="ufs nfs"
AC_MSG_RESULT([no flock64; configuring for file systems ufs and nfs])
fi
fi
MPI_OFFSET_KIND1=" INTEGER MPI_OFFSET_KIND"
MPI_OFFSET_KIND2=" PARAMETER (MPI_OFFSET_KIND=8)"
if test "$CC" != "gcc" ; then
ROMIO_TCFLAGS="-Ae"
fi
if test "$F77" != "g77" ; then
ROMIO_TFFLAGS="+U77"
fi
fi
#
if test -n "$arch_alpha" || test -n "$arch_ALPHA" ; then
CC=${CC:-cc}
F77=${FC:-f77}
if test $DEBUG = "yes"; then
CFLAGS="$CFLAGS -g -std1 -warnprotos -verbose"
else
CFLAGS="$CFLAGS -O"
fi
AC_DEFINE(AIO_PRIORITY_DEFAULT,,[Define for AIO priority is default])
MPI_LIB="$MPI_LIB -laio"
if test -z "$MPI" ; then
MPI=mpich
mpi_mpich=1
fi
if test -z "$FILE_SYSTEM" ; then
file_system_ufs=1
file_system_nfs=1
FILE_SYSTEM="ufs nfs"
AC_MSG_RESULT([configuring for file systems ufs and nfs])
fi
AC_DEFINE(DEC,,[Define for DEC/Compaq/HP Alpha])
MPI_OFFSET_KIND1=" INTEGER MPI_OFFSET_KIND"
MPI_OFFSET_KIND2=" PARAMETER (MPI_OFFSET_KIND=8)"
ROMIO_LIBLIST="-laio"
fi
#
if test -n "$arch_CRAY" ; then
CC=${CC:-cc}
F77=${FC:-f90}
NOF77=1
FTESTDEFINE="integer ilen"
F77GETARG="call pxfgetarg(i, str, ilen, ierr)"
if test $DEBUG = "yes"; then
CFLAGS="$CFLAGS -g"
else
CFLAGS="$CFLAGS -O"
fi
AC_DEFINE(NO_AIO,,[Define if AIO should not be used])
RANLIB=":"
CFLAGS="$CFLAGS -D_UNICOS"
AC_DEFINE(CRAY,,[Define if Cray])
if test -z "$MPI" || test -n "$mpi_sgi" ; then
MPI=cray
mpi_cray=1
mpi_sgi=""
# above is to disable configure tests specific to SGI MPI
AC_DEFINE(MPISGI,,[Define if SGI MPI])
AC_DEFINE(HAVE_MPI_COMBINERS,,[Define if MPI supports datatype combiners])
AC_DEFINE(NO_MPI_SGI_type_is_contig,,[Define if no types show contig])
fi
# MPISGI needed because of error in Cray's and SGI's
# MPI_Type_get_contents (does not increment reference count).
# Others needed because MPISGI needed.
if test -z "$FILE_SYSTEM" ; then
file_system_ufs=1
file_system_nfs=1
FILE_SYSTEM="ufs nfs"
AC_MSG_RESULT([configuring for file systems ufs and nfs])
fi
MPI_OFFSET_KIND1=" INTEGER MPI_OFFSET_KIND"
MPI_OFFSET_KIND2=" PARAMETER (MPI_OFFSET_KIND=8)"
fi
#
if test -n "$arch_sgi" ; then
arch_IRIX=1
ARCH=IRIX
fi
if test -n "$arch_IRIX64" ; then
arch_IRIX=1
fi
if test -n "$arch_IRIX32" ; then
arch_IRIX=1
fi
if test -n "$arch_IRIXN32" ; then
arch_IRIX=1
fi
if test -n "$arch_sgi5" ; then
arch_IRIX5=1
ARCH=IRIX
fi
#
PAC_GET_SPECIAL_SYSTEM_INFO
#
# special case 'sgi5' for use on MESHINE which is much like an SGI running
# irix 5 with r4400 chips, but does not have 'hinv', so above code doesn't
# work
if test -n "$arch_sgi5"; then
osversion=5
cputype=4400
IRIXARCH="$ARCH_$osversion"
IRIXARCH="$IRIXARCH_$cputype"
# now set arch_IRIX to 1
arch_IRIX=1
echo "IRIX-specific architecture is $IRIXARCH"
AC_DEFINE(IRIX,,[Define if IRIX])
fi
#
if test -n "$arch_IRIX"; then
CC=${CC:-cc}
F77=${FC:-f77}
if test $DEBUG = "yes"; then
CFLAGS="$CFLAGS -g -fullwarn"
else
CFLAGS="$CFLAGS -O"
fi
if test $osversion = 4 ; then
RANLIB="ar ts"
if test -n "$mpi_sgi"; then
AC_MSG_ERROR(["SGI's MPI doesn't work with IRIX 4.x"])
fi
elif test $osversion = 5 ; then
if test -n "$mpi_sgi"; then
AC_MSG_ERROR("SGI's MPI doesn't work with IRIX 5.x"])
fi
elif test $osversion = 6 ; then
if test -z "$MPI"; then
if test -f "/usr/include/mpi.h" ; then
echo "assuming that you want to use ROMIO with SGI's MPI"
MPI=sgi
mpi_sgi=1
else
echo "assuming that you want to use ROMIO with MPICH"
MPI=mpich
mpi_mpich=1
fi
fi
RANLIB=":"
AC_DEFINE(AIO_SIGNOTIFY_NONE,,[Define if no signotify])
if test $cputype -ge 5000 ; then
MIPS=4
else
MIPS=3
fi
fi
if test -n "$mpi_sgi" && test -z "$MPI_LIB" ; then
MPI_LIB="-lmpi"
fi
# check if pread64 is defined
PAC_HAVE_PREAD64
#
if test -z "$FILE_SYSTEM" ; then
file_system_nfs=1
FILE_SYSTEM="nfs"
AC_MSG_CHECKING(for xfs)
AC_TRY_COMPILE([
#include <aio.h>],
[aiocb64_t *t1;],file_system_xfs=1;FILE_SYSTEM="xfs $FILE_SYSTEM";)
if test "$file_system_xfs" = 1 ; then
AC_MSG_RESULT(yes)
else
AC_MSG_RESULT(no)
file_system_ufs=1
FILE_SYSTEM="ufs $FILE_SYSTEM"
fi
AC_MSG_RESULT([configuring for file systems $FILE_SYSTEM])
fi
AC_DEFINE(IRIX,,[Define if IRIX])
MPI_OFFSET_KIND1=" INTEGER MPI_OFFSET_KIND"
MPI_OFFSET_KIND2=" PARAMETER (MPI_OFFSET_KIND=8)"
fi
AC_HAVE_FUNCS(memalign)
PAC_TEST_MPIR_STATUS_SET_BYTES
if test $NOF77 = 0 ; then
echo "checking Fortran external names"
PAC_GET_FORTNAMES
if test -n "$WDEF" ; then
CFLAGS="$CFLAGS $WDEF"
fi
rm -f test/mpif.h
if test "$MPI_INCLUDE_DIR" != "." && test $FROM_MPICH = 0 && \
test $FROM_MPICH2 = 0 ; then
if test ! -d test ; then mkdir test ; fi
ln -s $MPI_INCLUDE_DIR/mpif.h test
fi
else
F77=":"
fi
#
# This is checked by the top-level OpenMPI configure-script.
# Avoid redefinition
#
# PAC_C_INLINE
# Header files
PAC_CHECK_HEADERS(unistd.h)
#
PAC_INT_LT_POINTER()
#
PAC_LONG_LONG_64()
#
dnl PAC_LONG_64()
#
if test -n "$longlongsize"; then
if test $FROM_MPICH = 0 -a $FROM_MPICH2 = 0 ; then
PAC_MPI_LONG_LONG_INT()
else
AC_DEFINE(HAVE_MPI_LONG_LONG_INT,,[Define if supports long long int])
fi
fi
#
if test -n "$OFFSET_KIND" -a "A$MPI_OFFSET_KIND1" = "A!" ; then
MPI_OFFSET_KIND1=" INTEGER MPI_OFFSET_KIND"
MPI_OFFSET_KIND2=" PARAMETER (MPI_OFFSET_KIND=$OFFSET_KIND)"
else
if test "$FORTRAN_MPI_OFFSET" = "integer*8" && test "A$MPI_OFFSET_KIND2" = "A!" && test $NOF77 = 0 ; then
PAC_MPI_OFFSET_KIND()
fi
#
if test "$FORTRAN_MPI_OFFSET" = "integer" && test "A$MPI_OFFSET_KIND2" = "A!" && test $NOF77 = 0 ; then
PAC_MPI_OFFSET_KIND_4BYTE()
fi
fi
#
# check if MPI_Info functions are defined in the MPI implementation
if test $FROM_MPICH = 0 -a $FROM_MPICH2 = 0 ; then
PAC_MPI_INFO()
else
AC_DEFINE(HAVE_MPI_INFO,,[Define if MPI Info is available])
HAVE_MPI_INFO="#define HAVE_MPI_INFO"
MPI_FINFO1="!"
MPI_FINFO2="!"
MPI_FINFO3="!"
MPI_FINFO4="!"
fi
#
if test -n "$mpi_sgi"; then
if test -z "$HAVE_MPI_INFO" ; then
PAC_CHECK_MPI_SGI_INFO_NULL # is MPI_INFO_NULL defined in mpi.h?
fi
PAC_TEST_MPI_SGI_type_is_contig
PAC_TEST_MPI_COMBINERS
PAC_TEST_MPI_HAVE_OFFSET_KIND
fi
#
# check if darray and subarray constructors are defined in the MPI implementation
if test $FROM_MPICH = 0 ; then
PAC_MPI_DARRAY_SUBARRAY()
else
AC_DEFINE(HAVE_MPI_DARRAY_SUBARRAY,,[Define if Darray is available])
HAVE_MPI_DARRAY_SUBARRAY="#define HAVE_MPI_DARRAY_SUBARRAY"
MPI_FARRAY1="!"
MPI_FARRAY2="!"
MPI_FARRAY3="!"
MPI_FARRAY4="!"
MPI_FARRAY5="!"
MPI_FARRAY6="!"
MPI_FARRAY7="!"
fi
#
# Check to see if the compiler accepts prototypes
dnl PAC_CHECK_CC_PROTOTYPES(AC_DEFINE(HAVE_PROTOTYPES))
#
#
# Test for weak symbol support...
# We can't put # in the message because it causes autoconf to generate
# incorrect code
HAVE_WEAK_SYMBOLS=0
if test -n "$arch_hpux" || test -n "$arch_sppux" ; then
# multiple secondary definitions not allowed by HP compilers
# Fortran interface for HP already uses one secondary defn.
# therefore, do not use this method for profiling interface.
# build profiling interface explicitly.
TRY_WEAK_SYMBOLS=0
fi
if test $TRY_WEAK_SYMBOLS = 1 ; then
AC_MSG_CHECKING(for weak symbol support)
AC_TRY_LINK([
#pragma weak PFoo = Foo
int Foo(a) { return a; }
],[return PFoo(1);],has_pragma_weak=1)
#
# Some systems (Linux ia64 and ecc, for example), support weak symbols
# only within a single object file! This tests that case.
if test "$has_pragma_weak" = 1 ; then
AC_MSG_RESULT([pragma weak])
AC_MSG_CHECKING([that weak symbols are visible to other files])
rm -f conftest*
cat >>conftest1.c <<EOF
#pragma weak PFoo = Foo
int Foo(int);
int Foo(a) { return a; }
EOF
cat >>conftest2.c <<EOF
int main() {
return PFoo(0);}
EOF
ac_link2='${CC-cc} -o conftest $CFLAGS $CPPFLAGS $LDFLAGS conftest1.c conftest2.c $LIBS >conftest.out 2>&1'
if eval $ac_link2 ; then
AC_MSG_RESULT(yes)
else
echo "$ac_link2" >>config.log
echo "Failed program was" >>config.log
cat conftest1.c >>config.log
cat conftest2.c >>config.log
if test -s conftest.out ; then cat conftest.out >> config.log ; fi
AC_MSG_RESULT(no)
has_pragma_weak=0
fi
rm -f conftest*
fi
if test "$has_pragma_weak" = 1 ; then
HAVE_WEAK_SYMBOLS=1
AC_DEFINE(HAVE_WEAK_SYMBOLS,,[Define if weak symbols available])
AC_DEFINE(HAVE_PRAGMA_WEAK,,[Define if pragma weak available])
else
AC_TRY_LINK([
#pragma _HP_SECONDARY_DEF Foo PFoo
int Foo(a) { return a; }
],[return PFoo(1);],has_pragma_hp_secondary=1)
if test "$has_pragma_hp_secondary" = 1 ; then
AC_MSG_RESULT([pragma _HP_SECONDARY_DEF])
HAVE_WEAK_SYMBOLS=1
AC_DEFINE(HAVE_WEAK_SYMBOLS,,[Define if weak symbols available])
AC_DEFINE(HAVE_PRAGMA_HP_SEC_DEF,,[Define for HP weak pragma])
else
AC_TRY_LINK([
#pragma _CRI duplicate PFoo as Foo
int Foo(a) { return a; }
],[return PFoo(1);],has_pragma_cri_duplicate=1)
if test "$has_pragma_cri_duplicate" = 1 ; then
AC_MSG_RESULT([pragma _CRI duplicate x as y])
HAVE_WEAK_SYMBOLS=1
AC_DEFINE(HAVE_WEAK_SYMBOLS,,[Define if weak symbols available])
AC_DEFINE(HAVE_PRAGMA_CRI_DUP,,[Define for CRAY weak dup])
else
AC_MSG_RESULT(no)
fi
fi
fi
fi
AC_SUBST(HAVE_WEAK_SYMBOLS)
#
# if FILE_SYSTEM is not set above, use ufs and nfs as default
#
if test -z "$FILE_SYSTEM" ; then
file_system_ufs=1
file_system_nfs=1
FILE_SYSTEM="ufs nfs"
AC_MSG_RESULT([configuring for file systems ufs and nfs])
fi
#
if test -n "$file_system_nfs" ; then
# Check for problems with locks
AC_MSG_CHECKING([whether file locks work with NFS])
AC_TRY_RUN([
#include <fcntl.h>
#include <errno.h>
#include <unistd.h>
int main()
{
struct flock lock;
int fd, err;
lock.l_type = F_WRLCK;
lock.l_start = 0;
lock.l_whence = SEEK_SET;
lock.l_len = 100;
fd = open("conftest.dat", O_RDWR | O_CREAT, 0644);
err = fcntl(fd, F_SETLKW, &lock);
/* printf("err = %d, errno = %d\n", err, errno); */
close(fd);
return err;
}],nfs_locks_work=yes,nfs_locks_work=no,nfs_locks_work=unknown)
AC_MSG_RESULT($nfs_locks_work)
if test "$nfs_locks_work" != "yes" ; then
AC_MSG_WARN([File locks do not work with NFS. See the Installation and
users manual for instructions on fixing this])
fi
fi
if test -n "$file_system_nfs"; then
AC_DEFINE(NFS,,[Define for NFS])
fi
if test -n "$file_system_ufs"; then
AC_DEFINE(UFS,,[Define for UFS])
fi
if test -n "$file_system_hfs"; then
AC_DEFINE(HFS,,[Define for HFS])
fi
if test -n "$file_system_sfs"; then
AC_DEFINE(SFS,,[Define for SFS])
fi
if test -n "$file_system_xfs"; then
AC_DEFINE(XFS,,[Define for XFS])
PAC_GET_XFS_MEMALIGN
fi
if test -n "$file_system_pvfs"; then
# Use ROMIO_PVFS instead of PVFS because FREEBSD defines PVFS.
AC_DEFINE(ROMIO_PVFS,,[Define for Romio with PVFS])
fi
if test -n "$file_system_pfs"; then
AC_DEFINE(PFS,,[Define for PFS])
fi
if test -n "$file_system_testfs"; then
AC_DEFINE(ROMIO_TESTFS,,[Define for TESTFS])
fi
if test -n "$file_system_piofs"; then
AC_DEFINE(PIOFS,,[Define for PIOFS])
USER_CFLAGS="$USER_CFLAGS -bI:/usr/include/piofs/piofs.exp"
ROMIO_LFLAGS="$USER_FFLAGS -bI:/usr/include/piofs/piofs.exp"
USER_FFLAGS="$USER_FFLAGS -bI:/usr/include/piofs/piofs.exp"
fi
if test -n "$mpi_mpich"; then
if test "$FROM_MPICH2" = 0; then
AC_DEFINE(NEEDS_MPI_TEST,,[Define if mpi_test needed])
AC_DEFINE(MPICH,,[Define if using MPICH])
if test -z "$arch_SX4" ; then
MPIOF_H_INCLUDED=1
fi
fi
fi
if test -n "$mpi_sgi"; then
AC_DEFINE(MPISGI,,[Define if SGI MPI])
fi
if test -n "$mpi_lam"; then
AC_DEFINE(MPILAM,,[Define if using LAM/MPI])
fi
if test -n "$mpi_hp"; then
AC_DEFINE(MPIHP,,[Define if using HP MPI])
if test "$NOF77" = 0; then
PAC_CHECK_MPIOF_H
fi
fi
#
PAC_FUNC_STRERROR
if test -z "$srcdir" -o "$srcdir" = "." ; then srcdir="$ROMIO_HOME" ; fi
AC_SUBST(srcdir)
if test "$FROM_MPICH2" = 0 ; then
if test -z "$LIBNAME"; then
LIBNAME="$ROMIO_HOME/lib/$ARCH/libmpio.a"
fi
#
if test ! -d $ROMIO_HOME/lib ; then
mkdir $ROMIO_HOME/lib
fi
if test ! -d $ROMIO_HOME/lib/$ARCH ; then
mkdir $ROMIO_HOME/lib/$ARCH
fi
else
if test -n "$top_build_dir" -a -d "$top_build_dir/lib" ; then
LIBNAME=$top_build_dir/lib/lib${MPILIBNAME}.a
else
LIBNAME="$ROMIO_HOME/lib${MPILIBNAME}.a"
fi
fi
#
if test $NOF77 = 1 ; then
F77=":"
else
FORTRAN_TEST="fperf fcoll_test fmisc pfcoll_test"
fi
#
if test $FROM_MPICH = 0 -a $FROM_MPICH2 = 0 ; then
PAC_TEST_MPI
PAC_NEEDS_FINT
else
NEEDS_MPI_FINT=""
fi
#
if test "$MPI_INCLUDE_DIR" = "." ; then
ROMIO_INCLUDE="-I../include"
else
ROMIO_INCLUDE="-I../include -I$MPI_INCLUDE_DIR"
fi
#
TEST_LIBNAME=$LIBNAME
MPIRUN=mpirun
#
# if MPICH, use mpicc in test programs
#
if test $FROM_MPICH = 1 ; then
MPICH_HOME=`dirname $ROMIO_HOME`
if test -z "$MPI_BIN_DIR" ; then MPI_BIN_DIR=$MPICH_HOME/bin ; fi
TEST_CC=$MPI_BIN_DIR/mpicc
MPI_LIB=""
ROMIO_INCLUDE=""
USER_CFLAGS=""
USER_FFLAGS=""
TEST_LIBNAME=""
MPIRUN=$MPI_BIN_DIR/mpirun
if test -n "$arch_SX4" || test -n "$arch_hpux" ; then
TEST_F77=$MPI_BIN_DIR/mpif90
else
TEST_F77=$MPI_BIN_DIR/mpif77
fi
CC=$MPI_BIN_DIR/mpicc
AC_DEFINE(HAVE_STATUS_SET_BYTES,,[Define if status_set_bytes available])
fi
# For now, separate the mpich2 from mpich cases
if test $FROM_MPICH2 = 1 ; then
MPICH_HOME=`dirname $ROMIO_HOME`
MPICH_HOME=`dirname $MPICH_HOME`
MPICH_HOME=`dirname $MPICH_HOME`
if test -z "$MPI_BIN_DIR" ; then MPI_BIN_DIR=$MPICH_HOME/bin ; fi
# No special compiler script.
# BUT we need the include paths
CC="$CC -I${use_top_srcdir}/src/include -I${top_build_dir}/src/include"
TEST_CC="$CC"
MPI_LIB="$LIBNAME"
ROMIO_INCLUDE=""
USER_CFLAGS=""
USER_FFLAGS=""
TEST_LIBNAME=""
MPIRUN=$MPI_BIN_DIR/mpiexec
AC_DEFINE(HAVE_STATUS_SET_BYTES,,[Define if status_set_bytes available])
fi
#
if test $MPI != "mpich" -o "$FROM_MPICH2" = 1 ; then
AC_DEFINE(PRINT_ERR_MSG,,[Define for printing error messages])
fi
#
if test -z "$TEST_CC" ; then
TEST_CC="$CC"
fi
if test -z "$TEST_F77" ; then
TEST_F77="$F77"
fi
#
CFLAGS="$CFLAGS -DHAVE_ROMIOCONF_H"
#
echo "setting CC to $CC"
echo "setting F77 to $F77"
echo "setting TEST_CC to $TEST_CC"
echo "setting TEST_F77 to $TEST_F77"
echo "setting CFLAGS to $CFLAGS"
echo "setting USER_CFLAGS to $USER_CFLAGS"
echo "setting USER_FFLAGS to $USER_FFLAGS"
#
VPATH='VPATH = .:${srcdir}'
AC_SUBST(VPATH)
AC_SUBST(ARCH)
AC_SUBST(FILE_SYSTEM)
AC_SUBST(CC)
AC_SUBST(CFLAGS)
AC_SUBST(USER_CFLAGS)
AC_SUBST(USER_FFLAGS)
AC_SUBST(MIPS)
AC_SUBST(BITS)
AC_SUBST(MPI)
AC_SUBST(AR)
AC_SUBST(RANLIB)
AC_SUBST(MPI_INCLUDE_DIR)
AC_SUBST(MPI_LIB)
AC_SUBST(F77)
AC_SUBST(NOF77)
AC_SUBST(NOPROFILE)
AC_SUBST(MAKE)
AC_SUBST(arch_IRIX)
AC_SUBST(ROMIO_HOME)
AC_SUBST(LIBNAME)
AC_SUBST(TEST_LIBNAME)
AC_SUBST(LL)
AC_SUBST(F77GETARG)
AC_SUBST(F77IARGC)
AC_SUBST(FTESTDEFINE)
AC_SUBST(FORTRAN_MPI_OFFSET)
AC_SUBST(FROM_MPICH)
AC_SUBST(FROM_MPICH2)
AC_SUBST(NEEDS_MPI_FINT)
AC_SUBST(HAVE_MPI_INFO)
AC_SUBST(BUILD_MPI_INFO)
AC_SUBST(HAVE_MPI_DARRAY_SUBARRAY)
AC_SUBST(BUILD_MPI_ARRAY)
AC_SUBST(DEFINE_MPI_OFFSET)
AC_SUBST(MPI_FINFO1)
AC_SUBST(MPI_FINFO2)
AC_SUBST(MPI_FINFO3)
AC_SUBST(MPI_FINFO4)
AC_SUBST(MPI_FARRAY1)
AC_SUBST(MPI_FARRAY2)
AC_SUBST(MPI_FARRAY3)
AC_SUBST(MPI_FARRAY4)
AC_SUBST(MPI_FARRAY5)
AC_SUBST(MPI_FARRAY6)
AC_SUBST(MPI_FARRAY7)
AC_SUBST(MPI_OFFSET_KIND1)
AC_SUBST(MPI_OFFSET_KIND2)
AC_SUBST(TEST_CC)
AC_SUBST(TEST_F77)
AC_SUBST(ROMIO_INCLUDE)
AC_SUBST(ROMIO_LFLAGS)
AC_SUBST(ROMIO_LIBLIST)
AC_SUBST(ROMIO_TCFLAGS)
AC_SUBST(ROMIO_TCPPFLAGS)
AC_SUBST(ROMIO_TFFLAGS)
AC_SUBST(MPIRUN)
AC_SUBST(FORTRAN_TEST)
if test ! -d adio ; then mkdir adio ; fi
if test ! -d adio/include ; then mkdir adio/include ; fi
if test ! -d mpi2-other ; then mkdir mpi2-other ; fi
#
# Make sure we remove any configuration file incase there is out-of-date data.
# We remove the version in include in case this is a vpath build
rm -f adio/include/romioconf.h ${use_top_srcdir}/src/mpi/romio/adio/include/romioconf.h ${use_top_srcdir}/adio/include/romioconf.h
#
# Create makefiles for all of the adio devices. Only the ones that
# are active will be called by the top level ROMIO make
AC_OUTPUT_COMMANDS([chmod 755 util/romioinstall test/runtests])
AC_OUTPUT(Makefile mpi-io/Makefile mpi2-other/info/Makefile \
mpi2-other/array/Makefile adio/common/Makefile \
test/Makefile test/misc.c test/large_file.c \
test/runtests util/romioinstall include/mpio.h \
include/mpiof.h \
adio/ad_nfs/Makefile adio/ad_ufs/Makefile \
adio/ad_xfs/Makefile adio/ad_hfs/Makefile \
adio/ad_sfs/Makefile adio/ad_pfs/Makefile \
adio/ad_testfs/Makefile adio/ad_pvfs/Makefile \
adio/ad_piofs/Makefile \
mpi-io/fortran/Makefile mpi2-other/info/fortran/Makefile \
mpi2-other/array/fortran/Makefile test/fmisc.f \
test/fcoll_test.f test/pfcoll_test.f test/fperf.f )
#
rm -f *.o
if test "$ROMIO_NO_BANNER" != "yes" -a "$FROM_MPICH" = 0 -a \
$FROM_MPICH2 = 0 ; then
cat <<EOF
Please register your copy of ROMIO with us by sending email
to majordomo@mcs.anl.gov with the message
subscribe romio-users
This will enable us to notify you of new releases of ROMIO
as well as bug fixes.
EOF
fi
if test $FROM_MPICH2 = 1 -a "$NOF77" = 0 ; then
sed 5d test/fcoll_test.f > test/tmp
mv test/tmp test/fcoll_test.f
sed 5d test/pfcoll_test.f > test/tmp
mv test/tmp test/fcoll_test.f
sed 5d test/fperf.f > test/tmp
mv test/tmp test/fperf.f
sed 5d test/fmisc.f > test/tmp
mv test/tmp test/fmisc.f
fi
if test $FROM_MPICH = 0 -a $FROM_MPICH2 = 0 ; then
AC_MSG_RESULT([Configure done. Now type make])
fi
dnl PAC_SUBDIR_CACHE_CLEANUP
exit 0
Показать git blame Копировать постоянную ссылку