80bb41a079
ROMIO configure looks for lstat in wrong header The ROMIO configure script checks for a declaration of lstat in unistd.h, but, at least on the Linux machines I checked, lstat is in sys/stat.h. (The detection failure led to a linker error when building ROMIO as part of OpenMPI on one of my admittedly strangely configured machines, somehow.) It appears from the man page that either location is possible, so check both. (cherry picked from mpich/mpich@7b8bd055df) Signed-off-by: Rob Latham <robl@mcs.anl.gov> Signed-off-by: Nathan Hjelm <hjelmn@lanl.gov>
1960 строки
60 KiB
Plaintext
1960 строки
60 KiB
Plaintext
# -*- Mode: shell-script -*-
|
|
# build with
|
|
# autoconf --localdir=../confdb configure.ac
|
|
# (or wherever the confdb is)
|
|
#
|
|
# irrelevant / unnecessary in an Open MPI environment, but are
|
|
# harmless and are left here solely for the sake of ease of future
|
|
# patching/importing.
|
|
AC_PREREQ([2.63])
|
|
|
|
# Open MPI: Modifications to this file were done on an "let's do the
|
|
# minimum possible" basis, not so that we can skip on the work or
|
|
# provide any less functionality, but more from a perspective that we
|
|
# want to be able to import new versions of ROMIO in as easy a fashion
|
|
# as possible. Hence, there are some things in this file that are
|
|
# irrelevant / unnecessary in an Open MPI environment, but are
|
|
# harmless and are left here solely for the sake of ease of future
|
|
# patching/importing.
|
|
AC_INIT([ROMIO],
|
|
[Open MPI],
|
|
[discuss@mpich.org],
|
|
[romio],
|
|
[http://www.mpich.org/])
|
|
|
|
dnl AC_CONFIG_AUX_DIR(../../../confdb)
|
|
dnl Set the directory that contains the required install-sh, config.sub,
|
|
dnl and config.guess . Make sure that these are updated (in MPICH, use
|
|
dnl the top-level confdb files). This separate directory is used for
|
|
dnl the moment to allow ROMIO to be separatedly distributed.
|
|
dnl scripts.
|
|
AC_CONFIG_AUX_DIR([confdb])
|
|
AC_CONFIG_MACRO_DIR([confdb])
|
|
|
|
AM_INIT_AUTOMAKE([-Wall -Werror -Wno-portability-recursive foreign 1.12 silent-rules subdir-objects])
|
|
AM_MAINTAINER_MODE([enable])
|
|
|
|
dnl must come before LT_INIT, which AC_REQUIREs AC_PROG_CC
|
|
PAC_PROG_CC
|
|
AM_PROG_CC_C_O
|
|
|
|
AM_PROG_AR
|
|
|
|
LT_INIT([])
|
|
# Non-verbose make by default
|
|
m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES([yes])])
|
|
|
|
# VERSION=1.2.6
|
|
# AC_MSG_RESULT([Configuring ROMIO Version $VERSION])
|
|
CONFIGURE_ARGS="$*"
|
|
if test -n "$CONFIGURE_ARGS" ; then
|
|
echo "Configuring with args $CONFIGURE_ARGS"
|
|
fi
|
|
|
|
AC_CONFIG_HEADER(adio/include/romioconf.h)
|
|
# Open MPI: modified AH_TOP
|
|
AH_TOP([/*
|
|
* (C) 2011 by Argonne National Laboratory.
|
|
* See COPYRIGHT in top-level directory.
|
|
*/
|
|
#ifndef ROMIOCONF_H_INCLUDED
|
|
#define ROMIOCONF_H_INCLUDED
|
|
|
|
#include "romioconf-undefs.h"
|
|
])
|
|
AH_BOTTOM([
|
|
/* quash PACKAGE and PACKAGE_* vars, see MPICH top-level configure.ac for
|
|
* more info */
|
|
#include "nopackage.h"
|
|
|
|
#endif /* !defined(ROMIOCONF_H_INCLUDED) */
|
|
])
|
|
|
|
# Open MPI: this configure script doesn't seem to define these
|
|
# anywhere, so just do them manually here because "we know better"
|
|
# (i.e., Open MPI can be hard-wired to these values).
|
|
AC_DEFINE([HAVE_MPI_OFFSET], [1], [Will always be 1 - OMPI has MPI_OFFSET])
|
|
|
|
# Open MPI: look for top Open MPI directory
|
|
AC_MSG_CHECKING([for Open MPI support files])
|
|
if test -f "$srcdir/../../../../../config/opal_mca.m4"; then
|
|
|
|
# This is needed for VPATH builds, so that it will -I the
|
|
# appropriate include directory (don't know why automake
|
|
# doesn't do this # automatically).
|
|
|
|
OMPI_TOP_SRCDIR='$(top_srcdir)/../../../../..'
|
|
OMPI_TOP_BUILDDIR='$(top_builddir)/../../../../..'
|
|
with_mpi="$OMPI_TOP_SRCDIR"
|
|
AC_MSG_RESULT([in Open MPI source tree -- good])
|
|
AC_SUBST(OMPI_TOP_SRCDIR)
|
|
AC_SUBST(OMPI_TOP_BUILDDIR)
|
|
else
|
|
AC_MSG_RESULT([not found])
|
|
AC_MSG_WARN([*** Could not find Open MPI support files])
|
|
AC_MSG_WARN([*** Can only build this version of ROMIO in an Open MPI source tree])
|
|
AC_MSG_ERROR([*** Cannot continue])
|
|
fi
|
|
|
|
dnl
|
|
# Open MPI: disable the f77 and f90 tests, as we provide our own
|
|
# MPI interface and use only the C parts of ROMIO
|
|
NOF77=1
|
|
NOF90=1
|
|
ARCH=""
|
|
arch_IRIX=""
|
|
MPI_IMPL=""
|
|
MPI_INCLUDE_DIR=""
|
|
ROMIO_INCLUDE=""
|
|
|
|
# Used by the new build system, should contain zero or more "-Iblah" args for
|
|
# inclusion in AM_CPPFLAGS. Should not contain relative paths. This probably
|
|
# overlaps with ROMIO_INCLUDE some, but adding a new var is easier than teasing
|
|
# apart all of the current usages of that variable and re-testing all of the
|
|
# non-MPICH and exotic platform cases.
|
|
MPI_H_INCLUDE=""
|
|
AC_SUBST([MPI_H_INCLUDE])
|
|
|
|
TEST_LIBNAME=""
|
|
FILE_SYSTEM=""
|
|
|
|
# Do not set variables to empty that may be communicated from the
|
|
# outside environment (e.g., MPI_LIB, MPI_BIN_DIR, LIBNAME)
|
|
DEBUG=no
|
|
MIPS=0
|
|
BITS=0
|
|
|
|
AC_ARG_VAR([FROM_MPICH],[set to "yes" if building ROMIO inside of MPICH])
|
|
FROM_MPICH=${FROM_MPICH:-no}
|
|
|
|
AC_ARG_VAR([FROM_LAM],[set to "yes" if building ROMIO inside of LAM])
|
|
FROM_LAM=${FROM_LAM:-no}
|
|
if test "$FROM_LAM" = 1 ; then FROM_LAM=yes ; fi
|
|
|
|
AC_ARG_VAR([FROM_OMPI],[set to "yes" if building ROMIO inside of Open MPI])
|
|
FROM_OMPI=${FROM_OMPI:-no}
|
|
if test "$FROM_OMPI" = 1 ; then FROM_OMPI=yes ; fi
|
|
|
|
AC_ARG_VAR([FROM_OMPI],[set to "yes" if building ROMIO inside of Open MPI])
|
|
FROM_OMPI=${FROM_OMPI:-no}
|
|
if test "$FROM_OMPI" = 1 ; then FROM_OMPI=yes ; fi
|
|
|
|
CFLAGS=${CFLAGS:-""}
|
|
LL="lld"
|
|
AR_LOCAL=""
|
|
DEFINE_HAVE_MPI_GREQUEST="#undef HAVE_MPI_GREQUEST"
|
|
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_TCFLAGS=""
|
|
ROMIO_TCPPFLAGS=""
|
|
ROMIO_TFFLAGS=""
|
|
NOPROFILE=0
|
|
MPIRUN=""
|
|
FORTRAN_TEST=""
|
|
# Open MPI: This (setting make) is a Bad Thing to do in Automake-based build systems
|
|
# MAKE=${MAKE:-"make"}
|
|
# foll. needed for f77 test programs
|
|
F77GETARG="call getarg(i,str)"
|
|
F77IARGC="iargc()"
|
|
F77MPIOINC=""
|
|
FTESTDEFINE=""
|
|
FORTRAN_MPI_OFFSET=""
|
|
MPIOF_H_INCLUDED=0
|
|
MPI_OFFSET_KIND1="!"
|
|
MPI_OFFSET_KIND2="!"
|
|
TEST_CC=""
|
|
TEST_F77=""
|
|
#
|
|
# Error handlers (not used with MPICH2, which provides its own routines)
|
|
MPIO_EXTRA_OBJECTS="get_errh.o set_errh.o"
|
|
MPIO_EXTRA_TMP_POBJECTS="get_errh.p set_errh.p"
|
|
MPIO_EXTRA_REAL_POBJECTS="_get_errh.o _set_errh.o"
|
|
#
|
|
# Completion routines for MPIO_Requests. MPI Implementations with
|
|
# generalized requests do not need these
|
|
# ioreq_c2f and ioreq_f2c are not MPIO_Requests; rather, they
|
|
MPIO_REQOBJECTS="iotest.o iotestall.o iotestany.o iotestsome.o iowait.o iowaitall.o iowaitany.o iowaitsome.o ioreq_c2f.o ioreq_f2c.o"
|
|
MPIO_REQ_TMP_POBJECTS="iotest.p iowait.p iowaitall.p iowaitany.p iotestall.p iotestany.p iowaitsome.p iotestsome.p"
|
|
MPIO_REQ_REAL_POBJECTS="_iotest.o _iowait.o _iowaitall.o _iowaitany.o _iotestall.o _iotestany.o _iowaitsome.o _iotestsome.o"
|
|
have_aio=no
|
|
#
|
|
known_mpi_impls="mpich_mpi mpich_mpi sgi_mpi hp_mpi cray_mpi lam_mpi open_mpi_mpi"
|
|
|
|
dnl An m4 macro for use with m4_foreach_w and friends. You should modify this
|
|
dnl list if you want to add a known file system. The list is just whitespace
|
|
dnl separated, so you can use newlines and tabs as well.
|
|
m4_define([known_filesystems_m4_w],
|
|
[nfs ufs pfs pvfs pvfs2 testfs xfs panfs gridftp lustre gpfs zoidfs hfs piofs sfs])dnl
|
|
dnl
|
|
dnl An m4 macro for use with m4_foreach and friends. Expands to a quoted list of
|
|
dnl quoted elements. A bit easier to use without unintended expansion than the
|
|
dnl whitespace version.
|
|
m4_define([known_filesystems_m4], m4_dquote(m4_map_args_w(m4_defn([known_filesystems_m4_w]),[],[],[,])))dnl
|
|
dnl
|
|
# a shell var for checking arguments given via --with-file-system=...
|
|
known_filesystems="m4_join([ ],known_filesystems_m4)"
|
|
|
|
#####################################################################
|
|
|
|
#
|
|
# Defaults
|
|
AC_ARG_ENABLE(aio,[
|
|
--enable-aio - Request use of asynchronous I/O routines (default)],
|
|
[
|
|
if test "x$enableval" = "xno" ; then
|
|
disable_aio=yes
|
|
else
|
|
disable_aio=no
|
|
fi
|
|
], disable_aio=no)
|
|
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_ENABLE(f90,
|
|
[--enable-f90 - Turn on support for Fortran 90 (default)],,enable_f90=yes)
|
|
AC_ARG_ENABLE(weak-symbols,
|
|
[--enable-weak-symbols - Turn on support for weak symbols],,enable_weak_symbols=no)
|
|
AC_ARG_ENABLE(debug,
|
|
[--enable-debug - Build a debugging version],,)
|
|
AC_ARG_WITH(file-system,[
|
|
--with-file-system=name - Build with support for the named file systems],,)
|
|
AC_ARG_WITH(pvfs2,[
|
|
--with-pvfs2=path - Path to installation of PVFS (version 2)],,)
|
|
AC_ARG_WITH(mpi-impl,[
|
|
--with-mpi-impl=name - Specify MPI implementation to build ROMIO for],,)
|
|
dnl
|
|
AC_ARG_WITH(mpi, [
|
|
--with-mpi=path - Path to instalation of MPI (headers, libs, etc)],,)
|
|
dnl
|
|
if test "$enable_f77" != "yes" ; then
|
|
NOF77=1
|
|
fi
|
|
if test "$enable_f90" != "yes" ; then
|
|
NOF90=1
|
|
fi
|
|
if test "$enable_debug" = "yes" ; then
|
|
DEBUG=yes
|
|
fi
|
|
MPI=$with_mpi
|
|
# Open MPI: No!
|
|
#if test -n "$with_mpi"; then
|
|
# CC=$MPI/bin/mpicc
|
|
#fi
|
|
|
|
# start with the set of file systems that the user asked for
|
|
# FILE_SYSTEM=$with_file_system
|
|
FILE_SYSTEM=`echo $with_file_system | sed -e 's/:.*$//'`
|
|
|
|
# Check if Make is working
|
|
PAC_PROG_MAKE
|
|
#
|
|
# Check that an arch was set
|
|
# If it wasn't set, try to guess using "util/tarch"
|
|
#
|
|
# Sometimes tarch looses its execute bit (!)
|
|
if test -s $srcdir/util/tarch -a ! -x $srcdir/util/tarch ; then
|
|
chmod a+x $srcdir/util/tarch
|
|
fi
|
|
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: Could not guess target architecture, you must
|
|
set an architecture type with the environment variable ARCH])
|
|
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
|
|
# Take advantage of autoconf2 features
|
|
if test -n "$ac_confdir" ; then
|
|
ROMIO_HOME_TRIAL=$ac_confdir
|
|
else
|
|
if test -s configure ; then
|
|
ROMIO_HOME_TRIAL=`pwd`
|
|
else
|
|
ac_confdir=`dirname "$0" 2>/dev/null`
|
|
if test -n "$ac_confdir" ; then
|
|
ROMIO_HOME_TRIAL=$ac_confdir
|
|
fi
|
|
fi
|
|
fi
|
|
fi
|
|
AC_MSG_RESULT([ROMIO home directory is $ROMIO_HOME_TRIAL])
|
|
ROMIO_HOME=$ROMIO_HOME_TRIAL
|
|
|
|
# get a fully qualified pathname for our build directory
|
|
top_build_dir=`pwd`
|
|
# used in romioinstall
|
|
AC_SUBST(top_build_dir)
|
|
|
|
# Open MPI: these shouldn't be needed with AM
|
|
#
|
|
# Create the "autoconf" style directory names...
|
|
# Most of these are done for us; add the documentation directories
|
|
#
|
|
# 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)
|
|
|
|
|
|
# If we are building within a known MPI implementation, we must avoid the
|
|
# tests about an existing implementation
|
|
if test "$FROM_MPICH" != no -o "$FROM_LAM" != no -o "$FROM_OMPI" != no ; then
|
|
WITHIN_KNOWN_MPI_IMPL=yes
|
|
else
|
|
WITHIN_KNOWN_MPI_IMPL=no
|
|
fi
|
|
|
|
# Open MPI: Set the MPI implementation
|
|
if test "$FROM_OMPI" = "yes" ; then
|
|
MPI_IMPL=open_mpi
|
|
fi
|
|
|
|
# check for valid MPI implementation
|
|
if test -n "$MPI_IMPL" ; then
|
|
found=no
|
|
for mpi in $known_mpi_impls ; do
|
|
if test "${MPI_IMPL}_mpi" = "$mpi" ; then
|
|
found=yes
|
|
break
|
|
fi
|
|
done
|
|
if test $found = no ; then
|
|
AC_MSG_WARN([Unknown MPI implementation $MPI... proceeding anyway])
|
|
fi
|
|
fi
|
|
#
|
|
|
|
if test -n "${with_mpi}" ; then
|
|
MPI_INCLUDE_DIR="${with_mpi}"/include
|
|
MPI_LIB_DIR="${with_mpi}"/lib
|
|
fi
|
|
|
|
# check for valid MPI include directory if specified
|
|
if test $WITHIN_KNOWN_MPI_IMPL = no ; 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 $WITHIN_KNOWN_MPI_IMPL = no ; 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
|
|
|
|
# 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
|
|
#
|
|
# Here begin the architecture-specific tests.
|
|
# --------------------------------------------------------------------------
|
|
# We must first select the C and Fortran compilers. Because of the
|
|
# way that the PROG_CC autoconf macro works (and all of the macros that
|
|
# require it, including CHECK_HEADERS), that macro must occur exactly
|
|
# once in the configure.ac file, at least as of autoconf 2.57 .
|
|
# Unfortunately, this requirement is not enforced. To handle this,
|
|
# we first case on the architecture; then use PROG_CC, then case on the
|
|
# architecture again for any arch-specific features. We also set the
|
|
# C_DEBUG_FLAG and F77_DEBUG_FLAG in case debugging is selected.
|
|
#
|
|
# For the MPICH and MPICH configures, the compilers will already be
|
|
# selected, so most of the compiler-selection code will be bypassed.
|
|
# --------------------------------------------------------------------------
|
|
# For historical reasons
|
|
if test -z "$FC" ; then
|
|
FC=$F77
|
|
fi
|
|
#
|
|
C_DEBUG_FLAG="-g"
|
|
F77_DEBUG_FLAG="-g"
|
|
|
|
dnl AC_PROG_{CXX,F77,FC} must come early in configure.ac in order to control
|
|
dnl compiler search order and avoid some esoteric autoconf macro expansion
|
|
dnl errors
|
|
if test "$enable_f77" = "yes" ; then
|
|
# suppress default "-g -O2" from AC_PROG_F77
|
|
: ${FFLAGS=""}
|
|
AC_PROG_F77([PAC_F77_SEARCH_LIST])
|
|
fi
|
|
if test "$enable_f90" = "yes" ; then
|
|
# suppress default "-g -O2" from AC_PROG_FC
|
|
: ${FCFLAGS=""}
|
|
AC_PROG_FC([PAC_FC_SEARCH_LIST])
|
|
fi
|
|
|
|
if test "$CC" = "gcc" -a -z "$C_DEBUG_FLAG" ; then
|
|
C_DEBUG_FLAG="-g -O -Wall -Wstrict-prototypes -Wmissing-prototypes"
|
|
fi
|
|
if test $DEBUG = "yes" ; then
|
|
CFLAGS="$CFLAGS $C_DEBUG_FLAG"
|
|
# Open MPI: don't add optflags - they'll come from the top-level configure
|
|
#else
|
|
# CFLAGS="$CFLAGS $C_OPT_FLAG"
|
|
fi
|
|
# ---------------------------------------------------------------------------
|
|
# Here go the rest of the tests
|
|
# ---------------------------------------------------------------------------
|
|
|
|
AC_CHECK_TYPE(long long)
|
|
AC_CHECK_SIZEOF(long long)
|
|
if test -z "$MPI_IMPL" ; then
|
|
MPI_IMPL=mpich
|
|
mpi_mpich=1
|
|
fi
|
|
if test $MPI_IMPL = "mpich" ; then
|
|
TEST_CC=mpicc
|
|
TEST_F77=mpifort
|
|
else
|
|
TEST_CC="$CC"
|
|
TEST_F77="$F77"
|
|
fi
|
|
# there used to be a ton of arch-specific stuff in here. If some random
|
|
# platform really truly needs it, restore it, but that defeats the whole
|
|
|
|
PAC_GET_SPECIAL_SYSTEM_INFO
|
|
|
|
AC_HAVE_FUNCS(memalign)
|
|
|
|
#
|
|
# Question: Should ROMIO under MPICH ignore the Fortran tests, since
|
|
# MPICH provides all of the Fortran interface routines?
|
|
#
|
|
if test $NOF77 = 0 ; then
|
|
echo "checking Fortran external names"
|
|
PAC_GET_FORTNAMES
|
|
if test -n "$WDEF" ; then
|
|
CFLAGS="$CFLAGS $WDEF"
|
|
fi
|
|
dnl PAC_PROG_F77_NAME_MANGLE
|
|
dnl (need to set the new name format)
|
|
rm -f test/mpif.h
|
|
if test "$MPI_INCLUDE_DIR" != "." && test $WITHIN_KNOWN_MPI_IMPL = no ; then
|
|
if test ! -d test ; then mkdir test ; fi
|
|
ln -s $MPI_INCLUDE_DIR/mpif.h test
|
|
fi
|
|
else
|
|
F77=":"
|
|
fi
|
|
#
|
|
# Open MPI: We already do this test top-level
|
|
dnl AC_C_INLINE
|
|
|
|
AC_TYPE_SIZE_T
|
|
AC_TYPE_SSIZE_T
|
|
AC_TYPE_OFF_T
|
|
|
|
# Header files
|
|
# Find the CPP before the header check
|
|
AC_PROG_CPP
|
|
AC_CHECK_HEADERS([unistd.h fcntl.h malloc.h stddef.h sys/types.h limits.h time.h])
|
|
AC_CHECK_HEADERS(mpix.h,,,[#include <mpi.h>])
|
|
#
|
|
|
|
# When compiling ROMIO on Darwin with _POSIX_C_SOURCE defined (such as when
|
|
# using --enable-strict in MPICH), sys/types.h does not define u_short and
|
|
# friends unless _DARWIN_C_SOURCE is also defined (see compat(5) on a Darwin
|
|
# box). This would normally be fine, except sys/stat.h defines struct stat to
|
|
# use u_long, so strict compiles fail. One option is to also compile with
|
|
# _DARWIN_C_SOURCE, but this disables much of the strictness that is intended
|
|
# by _POSIX_C_SOURCE. Instead we just define our own types if they are not
|
|
# provided by the system. This isn't quite as safe as typedef'ing the
|
|
# replacement types, but it will apply to later configure tests, which is
|
|
# important.
|
|
AC_CHECK_TYPE([u_char],[],[AC_DEFINE_UNQUOTED([u_char],[unsigned char],[Define to "unsigned char" if sys/types.h does not define.])])
|
|
AC_CHECK_TYPE([u_short],[],[AC_DEFINE_UNQUOTED([u_short],[unsigned short],[Define to "unsigned short" if sys/types.h does not define.])])
|
|
AC_CHECK_TYPE([u_int],[],[AC_DEFINE_UNQUOTED([u_int],[unsigned int],[Define to "unsigned int" if sys/types.h does not define.])])
|
|
AC_CHECK_TYPE([u_long],[],[AC_DEFINE_UNQUOTED([u_long],[unsigned long],[Define to "unsigned long" if sys/types.h does not define.])])
|
|
|
|
# must come _after_ the above checks for u_char/u_short/u_int/u_long
|
|
AC_CHECK_HEADERS([sys/attr.h])
|
|
|
|
AC_CHECK_SIZEOF(int)
|
|
AC_CHECK_SIZEOF(void *)
|
|
AC_CACHE_CHECK([for int large enough for pointers],
|
|
pac_cv_int_hold_pointer,[
|
|
if test "$ac_cv_sizeof_int" = "0" -o \
|
|
"$ac_cv_sizeof_void_p" = "0" ; then
|
|
pac_cv_int_hold_pointer=unknown
|
|
elif test "$ac_cv_sizeof_int" -lt "$ac_cv_sizeof_void_p" ; then
|
|
pac_cv_int_hold_pointer=no
|
|
else
|
|
pac_cv_int_hold_pointer=yes
|
|
fi
|
|
])
|
|
if test "$pac_cv_int_hold_pointer" != yes ; then
|
|
AC_DEFINE(INT_LT_POINTER,1,[Define if int smaller than pointer])
|
|
dnl Switch to a conforming name (start with HAVE or USE)
|
|
AC_DEFINE(HAVE_INT_LT_POINTER,1,[Define if int smaller than pointer])
|
|
fi
|
|
|
|
# LL is the printf-style format name for output of a MPI_Offset.
|
|
# We have to match this to the type that we use for MPI_Offset.
|
|
AC_CHECK_SIZEOF(long long)
|
|
if test "$ac_cv_sizeof_long_long" != 0 ; then
|
|
if test "$ac_cv_sizeof_long_long" = "8" ; then
|
|
AC_DEFINE(HAVE_LONG_LONG_64,1,[Define if long long is 64 bits])
|
|
MPI_OFFSET_TYPE="long long"
|
|
DEFINE_MPI_OFFSET="typedef long long MPI_Offset;"
|
|
FORTRAN_MPI_OFFSET="integer*8"
|
|
LL="lld"
|
|
elif test "$ac_cv_sizeof_long_long" = "$ac_cv_sizeof_int" ; then
|
|
MPI_OFFSET_TYPE="int"
|
|
DEFINE_MPI_OFFSET="typedef int MPI_Offset;"
|
|
FORTRAN_MPI_OFFSET="integer"
|
|
AC_DEFINE(MPI_OFFSET_IS_INT,1,[Define if MPI_Offset is int])
|
|
LL="d"
|
|
MPI_OFFSET_KIND1="!"
|
|
MPI_OFFSET_KIND2="!"
|
|
else
|
|
echo "defining MPI_Offset as long in C and integer in Fortran"
|
|
MPI_OFFSET_TYPE="long"
|
|
DEFINE_MPI_OFFSET="typedef long MPI_Offset;"
|
|
FORTRAN_MPI_OFFSET="integer"
|
|
LL="ld"
|
|
MPI_OFFSET_KIND1="!"
|
|
MPI_OFFSET_KIND2="!"
|
|
fi
|
|
else
|
|
echo "defining MPI_Offset as long in C and integer in Fortran"
|
|
MPI_OFFSET_TYPE="long"
|
|
DEFINE_MPI_OFFSET="typedef long MPI_Offset;"
|
|
FORTRAN_MPI_OFFSET="integer"
|
|
LL="ld"
|
|
MPI_OFFSET_KIND1="!"
|
|
MPI_OFFSET_KIND2="!"
|
|
fi
|
|
|
|
|
|
#
|
|
if test -n "$ac_cv_sizeof_long_long"; then
|
|
if test $WITHIN_KNOWN_MPI_IMPL = no ; then
|
|
PAC_MPI_LONG_LONG_INT
|
|
else
|
|
AC_DEFINE(HAVE_MPI_LONG_LONG_INT,1,[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)"
|
|
MPI_OFFSET_KIND_VAL=$OFFSET_KIND
|
|
else
|
|
if test "$FORTRAN_MPI_OFFSET" = "integer*8" && test "A$MPI_OFFSET_KIND2" = "A!" && test $NOF77 = 0 && test $NOF90 = 0 ; then
|
|
PAC_MPI_OFFSET_KIND
|
|
fi
|
|
#
|
|
if test "$FORTRAN_MPI_OFFSET" = "integer" && test "A$MPI_OFFSET_KIND2" = "A!" && test $NOF77 = 0 && test $NOF90 = 0 ; then
|
|
PAC_MPI_OFFSET_KIND_4BYTE
|
|
fi
|
|
fi
|
|
#
|
|
# Test that we can use the FORTRAN_MPI_OFFSET type. If the environment
|
|
# is a strict Fortran 90/95 or later compiler, the "integer*8" format
|
|
# may not work.
|
|
if test "$NOF77" = 0 ; then
|
|
rm -f conftest*
|
|
ac_cv_f77_offset_type_works=no
|
|
AC_MSG_CHECKING([that we can use $FORTRAN_MPI_OFFSET to declare MPI_DISPLACMENT_CURRENT])
|
|
cat >conftest.f <<EOF
|
|
program main
|
|
$FORTRAN_MPI_OFFSET j
|
|
end
|
|
EOF
|
|
if $F77 -o conftest$EXEEXT conftest.f >>config.log 2>&1 && test -x conftest$EXEEXT ; then
|
|
ac_cv_f77_offset_type_works=yes
|
|
fi
|
|
rm -f conftest*
|
|
AC_MSG_RESULT($ac_cv_f77_offset_type_works)
|
|
|
|
if test "$ac_cv_f77_offset_type_works" != "yes" -a -n "$MPI_OFFSET_KIND_VAL"; then
|
|
AC_MSG_CHECKING([whether we can use KIND with the selected F77 compiler $F77])
|
|
ac_cv_f77_allows_offset_kind=no
|
|
rm -f conftest*
|
|
cat >conftest.f <<EOF
|
|
program main
|
|
integer (kind=$MPI_OFFSET_KIND_VAL) j
|
|
end
|
|
EOF
|
|
if $F77 -o conftest$EXEEXT conftest.f >>config.log 2>&1 && test -x conftest$EXEEXT ; then
|
|
ac_cv_f77_allows_offset_kind=yes
|
|
fi
|
|
rm -f conftest*
|
|
AC_MSG_RESULT($ac_cv_f77_allows_offset_kind)
|
|
if test "$ac_cv_f77_allows_offset_kind" ; then
|
|
FORTRAN_MPI_OFFSET="integer (kind=$MPI_OFFSET_KIND_VAL)"
|
|
else
|
|
AC_MSG_WARN([Could not find a way to declare an integer type corresponding to MPI_Offset in Fortran.])
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
#
|
|
# check if MPI_Info functions are defined in the MPI implementation
|
|
if test $WITHIN_KNOWN_MPI_IMPL = no ; then
|
|
PAC_MPI_INFO
|
|
else
|
|
AC_DEFINE(HAVE_MPI_INFO,1,[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
|
|
dnl if test -z "$HAVE_MPI_INFO" ; then
|
|
dnl PAC_CHECK_MPI_SGI_INFO_NULL # is MPI_INFO_NULL defined in mpi.h?
|
|
dnl 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 $WITHIN_KNOWN_MPI_IMPL = no ; then
|
|
PAC_MPI_DARRAY_SUBARRAY
|
|
fi
|
|
if test $FROM_MPICH = yes ; then
|
|
dnl Made this a message instead of a warning because the warning is
|
|
dnl likely to confuse users.
|
|
AC_MSG_RESULT([Overriding Array test for MPICH])
|
|
unset BUILD_MPI_ARRAY
|
|
AC_DEFINE(HAVE_MPI_DARRAY_SUBARRAY,1,[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 weak symbols work correctly
|
|
if test "$enable_weak_symbols" = "yes" ; then
|
|
# Turn off weak symbols if they aren't available
|
|
PAC_PROG_C_WEAK_SYMBOLS(,enable_weak_symbols=no)
|
|
fi
|
|
if test "$enable_weak_symbols" = "yes" ; then
|
|
AC_DEFINE(USE_WEAK_SYMBOLS,1,[Define if weak symbols should be used])
|
|
# Check for the ability to support multiple weak symbols
|
|
if test "$pac_cv_prog_c_weak_symbols" = "pragma weak" ; then
|
|
PAC_PROG_C_MULTIPLE_WEAK_SYMBOLS(AC_DEFINE(HAVE_MULTIPLE_PRAGMA_WEAK,1,[Define if multiple weak symbols may be defined]))
|
|
fi
|
|
fi
|
|
|
|
if test "$enable_weak_symbols" = "yes" ; then
|
|
AC_DEFINE(HAVE_WEAK_SYMBOLS,1,[Define if weak symbols available])
|
|
HAVE_WEAK_SYMBOLS=1
|
|
else
|
|
HAVE_WEAK_SYMBOLS=0
|
|
fi
|
|
AC_SUBST(HAVE_WEAK_SYMBOLS)
|
|
|
|
AM_CONDITIONAL([BUILD_ROMIO_EMBEDDED],[test "$WITHIN_KNOWN_MPI_IMPL" = "yes" ])
|
|
# FIXME need to get this right for non-MPICH builds
|
|
AM_CONDITIONAL([BUILD_MPIO_REQUEST],[false])
|
|
# FIXME need to get this right for non-MPICH builds
|
|
AM_CONDITIONAL([BUILD_MPIO_ERRHAN],[false])
|
|
|
|
# if we don't have weak symbol support, we must build a separate convenience
|
|
# library in order to provide the "PMPI_" symbols
|
|
# Open MPI: Disable the profile library
|
|
#AM_CONDITIONAL([BUILD_PROFILING_LIB],[test "x$HAVE_WEAK_SYMBOLS" = "x0"])
|
|
AM_CONDITIONAL([BUILD_PROFILING_LIB],[false])
|
|
|
|
# weird: we have conflated "buid ROMIO's versions of the fortran bindings" and
|
|
# "build ROMIO"s fortran I/O tests". Of course the common situaiton is that we
|
|
# are building as part of MPICH, which builds its own fortran bindings, but we
|
|
# still want tests built
|
|
AM_CONDITIONAL([BUILD_F77_BINDINGS],[test "x$NOF77" != "x1" && test "x$FROM_MPICH" != "xyes"])
|
|
|
|
AM_CONDITIONAL([BUILD_F77_TESTS],[test "x$NOF77" != "x1"])
|
|
|
|
#
|
|
# Check whether the MPI Offset type is compatible with struct flock
|
|
AC_MSG_CHECKING([whether struct flock compatible with MPI_Offset])
|
|
AC_TRY_COMPILE([#include <fcntl.h>],
|
|
[struct flock l;
|
|
$MPI_OFFSET_TYPE a=1;
|
|
l.l_start = a;
|
|
l.l_len = a;
|
|
],pac_cv_struct_flock_and_mpi_offset=yes,pac_cv_struct_flock_and_mpi_offset=no)
|
|
AC_MSG_RESULT($pac_cv_struct_flock_and_mpi_offset)
|
|
# FIXME: We should look for struct flock64 and the F_SETLK64/F_GETLK64
|
|
# ADIOI_Set_lock could use these instead.
|
|
if test "$pac_cv_struct_flock_and_mpi_offset" = no ; then
|
|
AC_MSG_CHECKING([whether struct flock compatible with int])
|
|
AC_TRY_COMPILE([#include <fcntl.h>],
|
|
[struct flock l;
|
|
int a=1;
|
|
l.l_start = a;
|
|
l.l_len = a;
|
|
],pac_cv_struct_flock_and_int=yes,pac_cv_struct_flock_and_int=no)
|
|
AC_MSG_RESULT($pac_cv_struct_flock_and_int)
|
|
if test "$pac_cv_struct_flock_and_int" = yes ; then
|
|
AC_DEFINE(NEEDS_INT_CAST_WITH_FLOCK,1,[Define if l_start and l_len data should be cast as int])
|
|
fi
|
|
# FIXME. Solaris header files define off_t as a UNION if 64bit file
|
|
# sizes are selected. Gah!
|
|
fi
|
|
|
|
#
|
|
# if FILE_SYSTEM is not set above, use ufs and nfs as default
|
|
#
|
|
if test -z "$FILE_SYSTEM" ; then
|
|
FILE_SYSTEM="ufs nfs"
|
|
fi
|
|
|
|
# no matter what, always build testfs
|
|
FILE_SYSTEM="testfs $FILE_SYSTEM"
|
|
|
|
# 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
|
|
# We could also do test -d "ad_$y" to test for known file systems
|
|
# based on having access to the adio code. Then adding a file
|
|
# system would not require changing configure to change known_filesystems
|
|
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
|
|
|
|
#############################################
|
|
# This PVFS2 logic is special because it's hard to get it right if it comes
|
|
# before the known_filesystems check loop above. So we handle it down here,
|
|
# after the loop but before the AM_CONDITIONAL m4 loop.
|
|
#############################################
|
|
#
|
|
# An attempt to "do the right thing" with as little help from the end-user as
|
|
# possible:
|
|
# - if 'with-pvfs2' given, use that to find pvfs2-config. complain if we
|
|
# cannot find it, as this is probably what the user would expect
|
|
# - if we can find 'pvfs2-config' in our path, we can use it to set CFLAGS,
|
|
# LIBS, and LDFLAGS accordingly
|
|
# - as a fallback, use CFLAGS, LIBS, and LDFLAGS passed in by the user
|
|
# - don't do any of this if --with-file-system was given and did not include
|
|
# 'pvfs2': i.e. don't surprise the user with pvfs support.
|
|
|
|
AC_PATH_PROG(PVFS2_CONFIG, pvfs2-config, notfound, [${with_pvfs2}/bin:$PATH])
|
|
if test $PVFS2_CONFIG != "notfound" ; then
|
|
if test -n "${with_pvfs2}" -o -n "${file_system_pvfs2}" ; then
|
|
# the user either told us where pvfs is or asked for it in
|
|
# --with-file-system (or both)
|
|
CFLAGS="$CFLAGS $( $PVFS2_CONFIG --cflags)"
|
|
LIBS="$LIBS $( $PVFS2_CONFIG --libs)"
|
|
FILE_SYSTEM="pvfs2 $FILE_SYSTEM"
|
|
file_system_pvfs2=1
|
|
fi
|
|
fi
|
|
|
|
if test "$PVFS2_CONFIG" = "notfound" -a -n "$with_pvfs2" ; then
|
|
AC_MSG_ERROR([pvfs2-config not found in $with_pvfs2])
|
|
fi
|
|
#############################################
|
|
|
|
|
|
# Setup an AM_CONDITIONAL named BUILD_AD_FOO for use in each adio's Makefile.mk.
|
|
# This must come *after* the condition becomes valid, in this case after all
|
|
# $file_system_foo variables have been set.
|
|
#
|
|
# If you fiddle with this, please watch the m4 quoting carefully. m4_foreach
|
|
# expands any macros in the "list" argument exactly once. The defn bits ensure
|
|
# that any macro names in "fs"'s value will not be expanded, such as if someone
|
|
# is daft enough to "m4_define([ufs],[some crazy value])".
|
|
m4_foreach([fs],[known_filesystems_m4],[
|
|
AM_CONDITIONAL([BUILD_AD_]m4_toupper(defn([fs])),[test x$file_system_]defn([fs])[ = x1])
|
|
])
|
|
|
|
|
|
#
|
|
# Print list of configured file systems
|
|
#
|
|
# TODO: REMOVE BAD ONES FROM THE LIST SOMEHOW?
|
|
#
|
|
AC_MSG_CHECKING([configured file systems])
|
|
AC_MSG_RESULT([$FILE_SYSTEM])
|
|
|
|
|
|
if test -n "$file_system_nfs" ; then
|
|
AC_DEFINE(ROMIO_NFS,1,[Define for ROMIO with NFS])
|
|
AC_MSG_WARN([File locks may not work with NFS. See the Installation and
|
|
users manual for instructions on testing and if necessary fixing this])
|
|
fi
|
|
|
|
if test -n "$file_system_panfs"; then
|
|
# TODO: are there ever any installations with the panfs SDK somewhere else?
|
|
CPPFLAGS="${CPPFLAGS} -I/opt/panfs/include"
|
|
AC_CHECK_HEADER(pan_fs_client_cw_mode.h,
|
|
AC_DEFINE(ROMIO_PANFS,1,[Define for ROMIO with PANFS]),
|
|
AC_MSG_ERROR([PANFS support requested but cannot find pan_fs_client_cw_mode.h header file])
|
|
)
|
|
fi
|
|
|
|
if test -n "$file_system_ufs"; then
|
|
AC_DEFINE(ROMIO_UFS,1,[Define for ROMIO with UFS])
|
|
fi
|
|
|
|
changequote(<<,>>)
|
|
file_system_args=`echo $with_file_system | sed -e 's/^[^:]*//' -e 's/^://'`
|
|
changequote([,])
|
|
|
|
if test -n "$file_system_gpfs"; then
|
|
AC_DEFINE(ROMIO_GPFS,1,[Define for ROMIO with GPFS])
|
|
fi
|
|
|
|
AM_CONDITIONAL([BUILD_AD_BG],[false])
|
|
AM_CONDITIONAL([BUILD_AD_PE],[false])
|
|
if test "$file_system_args" = "BGQ" -a -n "$file_system_gpfs"; then
|
|
AC_DEFINE(BGQPLATFORM,1,BGQ platform)
|
|
AM_CONDITIONAL([BUILD_AD_BG],[true])
|
|
dnl what if anything can make Blue Gene support aio?
|
|
disable_aio=yes
|
|
fi
|
|
if test "$file_system_args" = "PE" -a -n "$file_system_gpfs"; then
|
|
AC_DEFINE(PEPLATFORM,1,PE platform)
|
|
AM_CONDITIONAL([BUILD_AD_PE],[true])
|
|
fi
|
|
|
|
# echo "with_file_system is :"$with_file_system": file_system_args is :"$file_system_args": FILE_SYSTEM is :"$FILE_SYSTEM":"
|
|
|
|
if test -n "$file_system_hfs"; then
|
|
AC_DEFINE(ROMIO_HFS,1,[Define for ROMIO with HFS])
|
|
fi
|
|
if test -n "$file_system_sfs"; then
|
|
AC_DEFINE(ROMIO_SFS,1,[Define for ROMIO with SFS])
|
|
fi
|
|
|
|
if test -n "$file_system_pfs"; then
|
|
AC_DEFINE(ROMIO_PFS,1,[Define for ROMIO with PFS])
|
|
fi
|
|
|
|
if test -n "$file_system_testfs"; then
|
|
AC_DEFINE(ROMIO_TESTFS,1,[Define for ROMIO with TESTFS])
|
|
fi
|
|
#
|
|
# Verify presence of lustre/lustre_user.h
|
|
#
|
|
if test -n "$file_system_lustre"; then
|
|
AC_CHECK_HEADERS(lustre/lustre_user.h,
|
|
AC_DEFINE(ROMIO_LUSTRE,1,[Define for ROMIO with LUSTRE]),
|
|
AC_MSG_ERROR([LUSTRE support requested but cannot find lustre/lustre_user.h header file])
|
|
)
|
|
fi
|
|
|
|
if test -n "$file_system_xfs"; then
|
|
AC_DEFINE(ROMIO_XFS,1,[Define for ROMIO with XFS])
|
|
# Check for memalign value
|
|
AC_CACHE_CHECK([for memory alignment needed for direct I/O],
|
|
pac_cv_memalignval,
|
|
[
|
|
rm -f confmemalignval
|
|
rm -f /tmp/romio_tmp.bin
|
|
AC_TRY_RUN([
|
|
#include <stdio.h>
|
|
#include <unistd.h>
|
|
#include <fcntl.h>
|
|
#include <stdio.h>
|
|
int main(int argc, char **argv) {
|
|
struct dioattr st;
|
|
int fd = open("/tmp/romio_tmp.bin", O_RDWR | O_CREAT, 0644);
|
|
FILE *f=fopen("confmemalignval","w");
|
|
if (fd == -1) exit(1);
|
|
if (!f) exit(1);
|
|
fcntl(fd, F_DIOINFO, &st);
|
|
fprintf( f, "%u\n", st.d_mem);
|
|
exit(0);
|
|
}
|
|
],
|
|
pac_cv_memalignval=`cat confmemalignval`,
|
|
pac_cv_memalignval="unknown",pac_cv_memalignval="unknown"
|
|
)
|
|
rm -f confmemalignval
|
|
rm -f /tmp/romio_tmp.bin
|
|
])
|
|
if test -n "$pac_cv_memalignval" -a "$pac_cv_memalignval" != 0 -a \
|
|
"$pac_cv_memalignval" != "unknown" ; then
|
|
CFLAGS="$CFLAGS -DXFS_MEMALIGN=$pac_cv_memalignval"
|
|
else
|
|
AC_MSG_RESULT(assuming 128 for memory alignment)
|
|
CFLAGS="$CFLAGS -DXFS_MEMALIGN=128"
|
|
fi
|
|
fi
|
|
|
|
#
|
|
# Verify presence of pvfs.h, issue with int64
|
|
#
|
|
if test -n "$file_system_pvfs"; then
|
|
CPPFLAGS="$CPPFLAGS $CFLAGS"
|
|
AC_CHECK_HEADERS(pvfs.h,
|
|
AC_DEFINE(ROMIO_PVFS,1,[Define for ROMIO with PVFS]),
|
|
AC_MSG_ERROR([PVFS support requested but cannot find pvfs.h header file])
|
|
)
|
|
# Check for missing int64_t (intel version 8 compiler and -no-gcc
|
|
# selected)
|
|
AC_MSG_CHECKING([that pvfs.h can be compiled])
|
|
AC_TRY_COMPILE([
|
|
#include <pvfs.h>
|
|
],[
|
|
],pvfs_header_ok=yes,pvfs_header_ok=no
|
|
)
|
|
AC_MSG_RESULT($pvfs_header_ok)
|
|
if test "$pvfs_header_ok" = no -a "$ac_cv_sizeof_long_long" = 8 ; then
|
|
AC_MSG_CHECKING([if pvfs.h can be compiled if we define int64_t])
|
|
# Try again, but with int64_t
|
|
AC_TRY_COMPILE([
|
|
typedef long long int int64_t;
|
|
#include <pvfs.h>
|
|
],[
|
|
],
|
|
pvfs_header_ok="yes with int64 definition"
|
|
)
|
|
AC_MSG_RESULT($pvfs_header_ok)
|
|
fi
|
|
if test "$pvfs_header_ok" = "yes with int64 definition" ; then
|
|
AC_DEFINE(ROMIO_PVFS_NEEDS_INT64_DEFINITION,1,[Define if int64_t must be defined for PVFS])
|
|
fi
|
|
if test "$pvfs_header_ok" != "no" ; then
|
|
AC_DEFINE(ROMIO_PVFS,1,[Define for ROMIO with PVFS])
|
|
AC_DEFINE(HAVE_PVFS_SUPER_MAGIC, 1, [Define if PVFS_SUPER_MAGIC defined.])
|
|
else
|
|
AC_MSG_WARN(missing or broken pvfs.h header file; disabling ROMIO PVFS support)
|
|
fi
|
|
fi
|
|
|
|
|
|
|
|
if test -n "$file_system_zoidfs"; then
|
|
AC_CHECK_HEADERS(zoidfs.h,
|
|
AC_DEFINE(ROMIO_ZOIDFS,1,[Define for ROMIO with ZoidFD]),
|
|
AC_MSG_ERROR([ZoidFS support requested but cannot find zoidfs.h header file])
|
|
)
|
|
fi
|
|
|
|
#
|
|
# Verify presence of pvfs2.h
|
|
#
|
|
if test -n "$file_system_pvfs2"; then
|
|
CPPFLAGS="$CPPFLAGS $CFLAGS"
|
|
AC_CHECK_HEADERS(pvfs2.h,
|
|
AC_DEFINE(ROMIO_PVFS2,1,[Define for ROMIO with PVFS2])
|
|
AC_DEFINE(HAVE_PVFS2_SUPER_MAGIC, 1, [Define if PVFS2_SUPER_MAGIC defined.]),
|
|
AC_MSG_ERROR([PVFS2 support requested but cannot find pvfs2.h header file])
|
|
)
|
|
fi
|
|
|
|
# layout change after pvfs-2.6.3:
|
|
if test -n "$file_system_pvfs2"; then
|
|
AC_COMPILE_IFELSE([
|
|
AC_LANG_SOURCE([
|
|
#include <stdlib.h>
|
|
#include "pvfs2.h"
|
|
int main(int argc, char **argv) {
|
|
PVFS_object_ref ref;
|
|
PVFS_sys_attr attr;
|
|
PVFS_sys_create(NULL, ref, attr, NULL, NULL, NULL, NULL);
|
|
return 0; }
|
|
])],
|
|
, AC_DEFINE(HAVE_PVFS2_CREATE_WITHOUT_LAYOUT, 1,
|
|
[Define if PVFS_sys_create does not have layout parameter])
|
|
)
|
|
fi
|
|
|
|
|
|
if test -n "$file_system_gridftp"; then
|
|
AC_DEFINE(ROMIO_GRIDFTP, 1, [Define for ROMIO with gridftp])
|
|
fi
|
|
|
|
AS_IF([test -n "$file_system_gpfs"],
|
|
[SYSDEP_INC=-I${prefix}/include], [SYSDEP_INC=])
|
|
|
|
AC_CHECK_HEADERS([gpfs.h gpfs_fcntl.h])
|
|
AS_IF([test "$ac_cv_header_gpfs_h" = "yes" -o "$ac_cv_header_gpfs_fcntl_h" = "yes"], [
|
|
AC_SEARCH_LIBS([gpfs_fcntl], [gpfs], [],
|
|
[AC_MSG_ERROR([Library containing gpfs_fcntl symbols not found])])
|
|
])
|
|
# Check for presence and characteristics of async. I/O calls if
|
|
# not disabled.
|
|
|
|
# Some systems need pthreads to get AIO to work. However, we don't want
|
|
# to add pthreads just because it is there, as that can cause problems
|
|
# with some implementations of pthreads and compilers (e.g., gcc version 3
|
|
# would fail if there was an int a[100000] on the stack if the application
|
|
# was *linked* with pthreads, but would succeed if the application was
|
|
# *not linked* with pthreads.
|
|
#
|
|
if test "x$disable_aio" = "xno" ; then
|
|
AC_SEARCH_LIBS(aio_write,aio rt,aio_write_found=yes,aio_write_found=no)
|
|
if test "$aio_write_found" = no ; then
|
|
# If not found, try finding pthread_create first, and if
|
|
# found, try the test again.
|
|
AC_SEARCH_LIBS(pthread_create,pthread,foundPTHREAD=yes,foundPTHREAD=no)
|
|
if test "$foundPTHREAD" = yes ; then
|
|
AC_SEARCH_LIBS(aio_write,aio rt,aio_write_found=yes,aio_write_found=no)
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
if test "x$disable_aio" = "xno" -a -n "$aio_write_found" ; then
|
|
AC_CHECK_HEADERS(signal.h)
|
|
# Just because aio.h is found by CPP doesn't mean that we can use it
|
|
# We try to compile it, not just read it.
|
|
AC_MSG_CHECKING([if aio.h exists and can be compiled])
|
|
AC_TRY_COMPILE([
|
|
#include <sys/types.h>
|
|
#include <aio.h>],
|
|
[],have_aio_h=yes,have_aio_h=no)
|
|
AC_MSG_RESULT($have_aio_h)
|
|
if test "$have_aio_h" = yes ; then
|
|
AC_DEFINE(HAVE_AIO_H,1,[Define if aio.h exists and can be compiled])
|
|
fi
|
|
|
|
AC_MSG_CHECKING([if sys/aio.h exists and can be compiled])
|
|
AC_TRY_COMPILE([
|
|
#include <sys/types.h>
|
|
#include <sys/aio.h>],
|
|
[],have_sys_aio_h=yes,have_sys_aio_h=no)
|
|
AC_MSG_RESULT($have_sys_aio_h)
|
|
if test "$have_sys_aio_h" = yes ; then
|
|
AC_DEFINE(HAVE_SYS_AIO_H,1,[Define if sys/aio.h exists and can be compiled])
|
|
fi
|
|
if test "$have_aio_h" = "no" -a "$have_sys_aio_h" = "no" ; then
|
|
disable_aio=yes
|
|
fi
|
|
fi
|
|
|
|
if test "$have_aio_h" = "yes" -o "$have_sys_aio_h" = "yes" -o "x$disable_aio" = "xno"; then
|
|
|
|
# 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])
|
|
# Include aio.h and the aiocb struct (since we'll need these to
|
|
# actually use the aio_write interface). Note that this will
|
|
# fail for some pre-POSIX implementations of the aio interface
|
|
# (an old IBM interface needs an fd argument as well)
|
|
AC_TRY_RUN([
|
|
#include <sys/types.h>
|
|
#ifdef HAVE_SIGNAL_H
|
|
#include <signal.h>
|
|
#endif
|
|
#ifdef HAVE_AIO_H
|
|
#include <aio.h>
|
|
#endif
|
|
#ifdef HAVE_SYS_AIO_H
|
|
#include <sys/aio.h>
|
|
#endif
|
|
int main(int argc, char **argv)
|
|
{
|
|
struct aiocb *aiocbp;
|
|
if (argc > 10) aio_write(aiocbp);
|
|
return 0;
|
|
}
|
|
],
|
|
aio_runs=yes
|
|
AC_MSG_RESULT(yes),
|
|
aio_runs=no
|
|
AC_MSG_RESULT(no),
|
|
aio_runs=no
|
|
AC_MSG_RESULT(no: aio routines disabled when cross compiling)
|
|
)
|
|
if test "$aio_runs" != "no" ; then
|
|
AC_DEFINE(ROMIO_HAVE_WORKING_AIO, 1, Define if AIO calls seem to work)
|
|
fi
|
|
|
|
# now about that old IBM interface...
|
|
# modern AIO interfaces have the file descriptor in the aiocb structure,
|
|
# and will set ROMIO_HAVE_STRUCT_AIOCB_WITH_AIO_FILDES. Old IBM
|
|
# implementations pass the file descriptor as an argument to aio_write and
|
|
# aio_read. AIO still works on these platforms, but we have to test with
|
|
# two-argument aio_write to avoid a false negative. no need to worry about
|
|
# the two-argument vs. one-argument aio_write and aio_read: ROMIO already
|
|
# uses ROMIO_HAVE_STRUCT_AIOCB_WITH_AIO_FILDES to call aio_write and
|
|
# aio_read correctly
|
|
|
|
AC_MSG_CHECKING([for obsolete two-argument aio_write])
|
|
AC_TRY_RUN([
|
|
#include <sys/types.h>
|
|
#ifdef HAVE_SIGNAL_H
|
|
#include <signal.h>
|
|
#endif
|
|
#ifdef HAVE_AIO_H
|
|
#include <aio.h>
|
|
#endif
|
|
#ifdef HAVE_SYS_AIO_H
|
|
#include <sys/aio.h>
|
|
#endif
|
|
int main(int argc, char **argv)
|
|
{
|
|
int fd;
|
|
struct aiocb *aiocbp;
|
|
if (argc > 10) aio_write(fd, aiocbp);
|
|
return 0;
|
|
}
|
|
],
|
|
aio_two_arg_write=yes
|
|
AC_MSG_RESULT(yes),
|
|
aio_two_arg_write=no
|
|
AC_MSG_RESULT(no),
|
|
aio_two_arg_write=no
|
|
AC_MSG_RESULT(no: cannot test when cross-compiling)
|
|
)
|
|
|
|
if test "$aio_two_arg_write" != "no" -a "$aio_runs" != "yes" ; then
|
|
AC_DEFINE(ROMIO_HAVE_WORKING_AIO, 1, Define if AIO calls seem to work)
|
|
AC_DEFINE(ROMIO_HAVE_AIO_CALLS_NEED_FILEDES, 1, Define if AIO calls need file descriptor)
|
|
fi
|
|
|
|
AC_MSG_CHECKING([for obsolete two-argument aio_suspend])
|
|
AC_TRY_RUN([
|
|
#include <sys/types.h>
|
|
#ifdef HAVE_SIGNAL_H
|
|
#include <signal.h>
|
|
#endif
|
|
#ifdef HAVE_AIO_H
|
|
#include <aio.h>
|
|
#endif
|
|
#ifdef HAVE_SYS_AIO_H
|
|
#include <sys/aio.h>
|
|
#endif
|
|
int main(int argc, char **argv)
|
|
{
|
|
struct aiocb *aiocbp;
|
|
if (argc > 10) aio_suspend(1, &aiocbp);
|
|
return 0;
|
|
}
|
|
],
|
|
aio_two_arg_suspend=yes
|
|
AC_MSG_RESULT(yes),
|
|
aio_two_arg_suspend=no
|
|
AC_MSG_RESULT(no),
|
|
aio_two_arg_suspend=no
|
|
AC_MSG_RESULT(no: cannot test when cross compiling)
|
|
)
|
|
|
|
if test "$aio_two_arg_suspend" != "no" -a "$aio_runs" != "yes" ; then
|
|
AC_DEFINE(ROMIO_HAVE_AIO_SUSPEND_TWO_ARGS, 1, Define if aio_suspend needs two arguments)
|
|
fi
|
|
|
|
AC_MSG_CHECKING([for aio_fildes member of aiocb structure])
|
|
AC_TRY_COMPILE([
|
|
#ifdef HAVE_SIGNAL_H
|
|
#include <signal.h>
|
|
#endif
|
|
#ifdef HAVE_SYS_TYPES_H
|
|
#include <sys/types.h>
|
|
#endif
|
|
#ifdef HAVE_AIO_H
|
|
#include <aio.h>
|
|
#endif
|
|
#ifdef HAVE_SYS_AIO_H
|
|
#include <sys/aio.h>
|
|
#endif
|
|
],[
|
|
struct aiocb a;
|
|
a.aio_fildes = 0;
|
|
],
|
|
AC_MSG_RESULT(yes)
|
|
AC_DEFINE(ROMIO_HAVE_STRUCT_AIOCB_WITH_AIO_FILDES, 1, [Define if aiocb has aio_fildes member]),
|
|
AC_MSG_RESULT(no)
|
|
)
|
|
AC_MSG_CHECKING(for aio_whence member of aiocb structure)
|
|
AC_TRY_COMPILE([
|
|
#ifdef HAVE_SIGNAL_H
|
|
#include <signal.h>
|
|
#endif
|
|
#ifdef HAVE_SYS_TYPES_H
|
|
#include <sys/types.h>
|
|
#endif
|
|
#ifdef HAVE_AIO_H
|
|
#include <aio.h>
|
|
#endif
|
|
#ifdef HAVE_SYS_AIO_H
|
|
#include <sys/aio.h>
|
|
#endif
|
|
#include <sys/types.h>
|
|
#include <unistd.h>
|
|
],[
|
|
struct aiocb a;
|
|
a.aio_whence = SEEK_SET;
|
|
],
|
|
AC_MSG_RESULT(yes)
|
|
AC_DEFINE(ROMIO_HAVE_STRUCT_AIOCB_WITH_AIO_WHENCE, 1, [Define if aiocb has aio_whence member]),
|
|
AC_MSG_RESULT(no)
|
|
)
|
|
AC_MSG_CHECKING(for aio_handle member of aiocb structure)
|
|
AC_TRY_COMPILE([
|
|
#ifdef HAVE_SIGNAL_H
|
|
#include <signal.h>
|
|
#endif
|
|
#ifdef HAVE_SYS_TYPES_H
|
|
#include <sys/types.h>
|
|
#endif
|
|
#ifdef HAVE_AIO_H
|
|
#include <aio.h>
|
|
#endif
|
|
#ifdef HAVE_SYS_AIO_H
|
|
#include <sys/aio.h>
|
|
#endif
|
|
],[
|
|
struct aiocb a;
|
|
aio_handle_t h;
|
|
|
|
a.aio_handle = h;
|
|
],
|
|
AC_MSG_RESULT(yes)
|
|
AC_DEFINE(ROMIO_HAVE_STRUCT_AIOCB_WITH_AIO_HANDLE, 1, [Define if aiocb has aio_handle member]),
|
|
AC_MSG_RESULT(no)
|
|
)
|
|
AC_MSG_CHECKING(for aio_reqprio member of aiocb structure)
|
|
AC_TRY_COMPILE([
|
|
#ifdef HAVE_SIGNAL_H
|
|
#include <signal.h>
|
|
#endif
|
|
#ifdef HAVE_SYS_TYPES_H
|
|
#include <sys/types.h>
|
|
#endif
|
|
#ifdef HAVE_AIO_H
|
|
#include <aio.h>
|
|
#endif
|
|
#ifdef HAVE_SYS_AIO_H
|
|
#include <sys/aio.h>
|
|
#endif
|
|
],[
|
|
struct aiocb a;
|
|
|
|
a.aio_reqprio = 0;
|
|
],
|
|
AC_MSG_RESULT(yes)
|
|
AC_DEFINE(ROMIO_HAVE_STRUCT_AIOCB_WITH_AIO_REQPRIO, 1, [Define if aiocb has aio_reqprio member]),
|
|
AC_MSG_RESULT(no)
|
|
)
|
|
AC_MSG_CHECKING(for aio_sigevent member of aiocb structure)
|
|
AC_TRY_COMPILE([
|
|
#ifdef HAVE_SIGNAL_H
|
|
#include <signal.h>
|
|
#endif
|
|
#ifdef HAVE_SYS_TYPES_H
|
|
#include <sys/types.h>
|
|
#endif
|
|
#ifdef HAVE_AIO_H
|
|
#include <aio.h>
|
|
#endif
|
|
#ifdef HAVE_SYS_AIO_H
|
|
#include <sys/aio.h>
|
|
#endif
|
|
],[
|
|
struct aiocb a;
|
|
|
|
a.aio_sigevent.sigev_signo = 0;
|
|
],
|
|
AC_MSG_RESULT(yes)
|
|
AC_DEFINE(ROMIO_HAVE_STRUCT_AIOCB_WITH_AIO_SIGEVENT, 1, [Define if aiocb has aio_sigevent member]),
|
|
AC_MSG_RESULT(no)
|
|
)
|
|
|
|
fi
|
|
|
|
# End of aio-related tests
|
|
|
|
#
|
|
# Check for statfs (many) and specifically f_fstypename field (BSD)
|
|
#
|
|
AC_CHECK_HEADERS(sys/vfs.h sys/param.h sys/mount.h sys/statvfs.h)
|
|
AC_CHECK_FUNCS([statfs])
|
|
AC_MSG_CHECKING([whether struct statfs properly defined])
|
|
AC_TRY_COMPILE([
|
|
#ifdef HAVE_SYS_VFS_H
|
|
#include <sys/vfs.h>
|
|
#endif
|
|
#ifdef HAVE_SYS_STATVFS_H
|
|
#include <sys/statvfs.h>
|
|
#endif
|
|
#ifdef HAVE_SYS_PARAM_H
|
|
#include <sys/param.h>
|
|
#endif
|
|
#ifdef HAVE_SYS_MOUNT_H
|
|
#include <sys/mount.h>
|
|
#endif
|
|
],[
|
|
struct statfs f;
|
|
],
|
|
pac_cv_have_statfs=yes,pac_cv_have_statfs=no
|
|
)
|
|
AC_MSG_RESULT($pac_cv_have_statfs)
|
|
# At this point, we could check for whether defining
|
|
# __SWORD_TYPE as sizet_t or int/long (size of pointer)
|
|
# would help. FIXME
|
|
|
|
if test "$pac_cv_have_statfs" = yes ; then
|
|
AC_DEFINE(HAVE_STRUCT_STATFS,1,[Define if struct statfs can be compiled])
|
|
fi
|
|
|
|
AC_MSG_CHECKING([for f_fstypename member of statfs structure])
|
|
AC_TRY_COMPILE([
|
|
#include <sys/param.h>
|
|
#include <sys/mount.h>
|
|
#include <string.h>
|
|
],[
|
|
struct statfs f;
|
|
memset(&f, 0, sizeof(f));
|
|
strncmp("nfs", f.f_fstypename, 3);
|
|
],
|
|
pac_cv_have_statfs_f_fstypename=yes,
|
|
pac_cv_have_statfs_f_fstypename=no
|
|
)
|
|
AC_MSG_RESULT($pac_cv_have_statfs_f_fstypename)
|
|
if test $pac_cv_have_statfs_f_fstypename = yes ; then
|
|
AC_DEFINE(ROMIO_HAVE_STRUCT_STATFS_WITH_F_FSTYPENAME, 1,[Define if statfs has f_fstypename])
|
|
fi
|
|
|
|
#
|
|
# Check for stat and st_fstype field (NEC SX4)
|
|
#
|
|
AC_CHECK_HEADERS(sys/stat.h sys/types.h unistd.h)
|
|
AC_CHECK_FUNCS(stat,
|
|
AC_DEFINE(HAVE_STAT, 1, Define if stat function is present)
|
|
AC_MSG_CHECKING([for st_fstype member of stat structure])
|
|
AC_TRY_COMPILE([
|
|
#ifdef HAVE_SYS_TYPES_H
|
|
#include <sys/types.h>
|
|
#endif
|
|
#ifdef HAVE_SYS_STAT_H
|
|
#include <sys/stat.h>
|
|
#endif
|
|
#ifdef HAVE_UNISTD_H
|
|
#include <unistd.h>
|
|
#endif
|
|
],[
|
|
struct stat s;
|
|
|
|
s.st_fstype = NULL;
|
|
],
|
|
AC_MSG_RESULT(yes)
|
|
AC_DEFINE(ROMIO_HAVE_STRUCT_STAT_WITH_ST_FSTYPE, 1, Define if struct stat has a st_fstype member),
|
|
AC_MSG_RESULT(no)
|
|
)
|
|
)
|
|
|
|
#
|
|
# Check for statvfs and f_basetype field (Solaris, Irix, AIX, etc.)
|
|
#
|
|
AC_CHECK_HEADERS(sys/types.h sys/statvfs.h sys/vfs.h)
|
|
AC_CHECK_FUNCS(statvfs,
|
|
AC_DEFINE(HAVE_STATVFS, 1, Define if statvfs function is present)
|
|
AC_MSG_CHECKING([for f_basetype member of statvfs structure])
|
|
AC_TRY_COMPILE([
|
|
#ifdef HAVE_SYS_TYPES_H
|
|
#include <sys/types.h>
|
|
#endif
|
|
#ifdef HAVE_SYS_VFS_H
|
|
#include <sys/vfs.h>
|
|
#endif
|
|
#ifdef HAVE_SYS_STATVFS_H
|
|
#include <sys/statvfs.h>
|
|
#endif
|
|
], [[
|
|
struct statvfs foo;
|
|
|
|
foo.f_basetype[0] = 'a';
|
|
]],
|
|
AC_MSG_RESULT(yes)
|
|
AC_DEFINE(ROMIO_HAVE_STRUCT_STATVFS_WITH_F_BASETYPE, 1, defined if struct statvfs has a f_basetype member),
|
|
AC_MSG_RESULT(no)
|
|
)
|
|
)
|
|
|
|
AC_CHECK_TYPE([blksize_t],[],[AC_DEFINE_UNQUOTED([blksize_t],[__blksize_t],[Provide blksize_t if not available]) ], [[
|
|
#ifdef HAVE_SYS_TYPES_H
|
|
#include <sys/types.h>
|
|
#endif
|
|
#ifdef HAVE_SYS_STAT_H
|
|
#include <sys/stat.h>
|
|
#endif
|
|
#ifdef HAVE_UNISTD_H
|
|
#include <unistd.h>
|
|
#endif]] )
|
|
|
|
#
|
|
# Check for large file support. Make sure that we can use the off64_t
|
|
# type (in some cases, it is an array, and the ROMIO code isn't prepared for
|
|
# that).
|
|
#
|
|
AC_CHECK_HEADERS(unistd.h)
|
|
if test "$ac_cv_header_unistd_h" = "yes" ; then
|
|
AC_CACHE_CHECK([for large file defines],ac_cv_has_large_file_defines,[
|
|
AC_TRY_COMPILE([
|
|
#include <unistd.h>
|
|
], [
|
|
#ifndef _LFS64_LARGEFILE
|
|
#error no largefile defines
|
|
#endif
|
|
],ac_cv_has_large_file_defines=yes,ac_cv_has_large_file_defines=no)])
|
|
if test "$ac_cv_has_large_file_defines" = "yes" ; then
|
|
# See if we can use them
|
|
AC_CACHE_CHECK([whether off64_t is an scalar type],ac_cv_off64_t_scalar,[
|
|
AC_TRY_COMPILE([
|
|
#define _LARGEFILE64_SOURCE
|
|
#define _FILE_OFFSET_BITS 64
|
|
#include <sys/types.h>
|
|
#include <unistd.h>
|
|
],[off64_t a = 3;],ac_cv_off64_t_scalar=yes,ac_cv_off64_t_scalar=no)])
|
|
|
|
if test "$ac_cv_off64_t_scalar" = "yes" ; then
|
|
CFLAGS="${CFLAGS} -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
# pread and pwrite are useful to ROMIO: if implemented well, they help us avoid
|
|
# an extra system call. But --enable-strict or CFLAGS="--std=c99" does not
|
|
# expose this feature. If we define XOPEN_SOURCE in ROMIO, we cause headaches
|
|
# for some versions of lustre, quota.h, and caddr_t. see if we need to provide
|
|
# our own pread/pwrite
|
|
|
|
AC_CHECK_DECLS([pwrite])
|
|
|
|
|
|
####################################################################
|
|
# We're about to mess with CC etc. No more feature tests past here,
|
|
# because we may set CC to something that does not yet exist!
|
|
####################################################################
|
|
|
|
if test -n "$mpi_mpich"; then
|
|
if test -z "$arch_SX4" ; then
|
|
MPIOF_H_INCLUDED=1
|
|
fi
|
|
if test "$FROM_MPICH" = no; then
|
|
AC_DEFINE(NEEDS_MPI_TEST,1,[Define if mpi_test needed])
|
|
AC_DEFINE(MPICH,1,[Define if using MPICH])
|
|
fi
|
|
fi
|
|
|
|
if test -n "$mpi_sgi"; then
|
|
AC_DEFINE(MPISGI,1,[Define if SGI MPI])
|
|
fi
|
|
|
|
if test -n "$mpi_lam"; then
|
|
AC_DEFINE(MPILAM,1,[Define if using LAM/MPI])
|
|
fi
|
|
|
|
if test -n "$mpi_hp"; then
|
|
AC_DEFINE(MPIHP,1,[Define if using HP MPI])
|
|
if test "$NOF77" = 0; then
|
|
PAC_CHECK_MPIOF_H
|
|
fi
|
|
fi
|
|
#
|
|
AC_CHECK_FUNCS(strerror)
|
|
if test -z "$srcdir" -o "$srcdir" = "." ; then srcdir="$ROMIO_HOME" ; fi
|
|
AC_SUBST(srcdir)
|
|
|
|
# preserve these values across a config.status --recheck
|
|
AC_ARG_VAR([master_top_srcdir],[set by the MPICH configure to indicate the MPICH source root])
|
|
AC_ARG_VAR([master_top_builddir],[set by the MPICH configure to indicate the MPICH build root])
|
|
|
|
# The master_top_srcdir is the location of the source for the building
|
|
# package. This is used only as part of the MPICH build, including
|
|
# the documentation targets mandoc, htmldoc, and latexdoc
|
|
if test -z "$master_top_srcdir" ; then
|
|
if test "$FROM_MPICH" = yes ; then
|
|
AC_MSG_WARN([Could not determine master_top_srcdir])
|
|
fi
|
|
fi
|
|
#
|
|
# Get the master builddir (which may be imported from above)
|
|
if test -z "$master_top_builddir" ; then
|
|
if test "$FROM_MPICH" = yes ; then
|
|
# this variable is essential to proper build operation
|
|
AC_MSG_ERROR([Could not determine master_top_srcdir])
|
|
fi
|
|
master_top_builddir=`pwd`
|
|
fi
|
|
# Make sure the alternate spelling is used until we clean up all of the code
|
|
master_topbuild_dir=$master_top_builddir
|
|
export master_topbuild_dir
|
|
AC_SUBST(master_topbuild_dir)
|
|
|
|
# The following definitions are needed within adio/common/status_setb.c
|
|
if test "$FROM_MPICH" = yes ; then
|
|
AC_DEFINE(ROMIO_INSIDE_MPICH,1,[Define if compiling within MPICH])
|
|
elif test "$FROM_MPILAM" = yes ; then
|
|
AC_DEFINE(MPILAM,1,[Define if compiling within LAM/MPI])
|
|
fi
|
|
|
|
if test "$FROM_MPICH" = no ; then
|
|
if test -z "$LIBNAME"; then
|
|
LIBNAME="$top_build_dir/lib/libmpio.a"
|
|
fi
|
|
#
|
|
if test ! -d $top_build_dir/lib ; then
|
|
mkdir $top_build_dir/lib
|
|
fi
|
|
else
|
|
MPILIBNAME=${MPILIBNAME:-mpich}
|
|
if test -z "$LIBNAME" ; then
|
|
if test -d "$master_top_builddir/lib" ; then
|
|
LIBNAME=$master_top_builddir/lib/lib${MPILIBNAME}.a
|
|
else
|
|
LIBNAME="$ROMIO_HOME/lib${MPILIBNAME}.a"
|
|
fi
|
|
fi
|
|
fi
|
|
if test "$FROM_MPICH" != no ; then
|
|
# use the error handlers from MPICH
|
|
MPIO_EXTRA_OBJECTS=
|
|
MPIO_EXTRA_TMP_POBJECTS=
|
|
MPIO_EXTRA_REAL_POBJECTS=
|
|
# Use generalized request to get the multiple-completion routines
|
|
MPIO_REQOBJECTS=
|
|
fi
|
|
AC_SUBST(MPIO_EXTRA_OBJECTS)
|
|
AC_SUBST(MPIO_EXTRA_TMP_POBJECTS)
|
|
AC_SUBST(MPIO_EXTRA_REAL_POBJECTS)
|
|
#
|
|
# Use DOCTEXT instead of doctext
|
|
AC_CHECK_PROGS(DOCTEXT,doctext,true)
|
|
AC_SUBST(DOCTEXT)
|
|
#
|
|
if test $NOF77 = 1 ; then
|
|
F77=":"
|
|
else
|
|
FORTRAN_TEST="fperf fcoll_test fmisc pfcoll_test"
|
|
fi
|
|
#
|
|
if test $WITHIN_KNOWN_MPI_IMPL = no ; 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 test $FROM_OMPI = yes ; then
|
|
# Open MPI does have the status set bytes functionality
|
|
|
|
AC_DEFINE(HAVE_STATUS_SET_BYTES,1,[Define if have MPIR_Status_set_bytes])
|
|
|
|
# Used in the tests/ subdirectory for after ROMIO is built
|
|
|
|
TEST_CC=mpicc
|
|
TEST_F77=mpifort
|
|
MPIRUN=mpirun
|
|
MPI_LIB=
|
|
NOPROFILE=1
|
|
ROMIO_INCLUDE=
|
|
USER_CFLAGS=
|
|
USER_FFLAGS=
|
|
TEST_LIBNAME=
|
|
AC_DEFINE(HAVE_MPI_DARRAY_SUBARRAY,1,[Define if Darray is available])
|
|
HAVE_MPI_DARRAY_SUBARRAY="#define HAVE_MPI_DARRAY_SUBARRAY"
|
|
# Open MPI: see comments in mpi-io/mpioprof.h
|
|
AC_DEFINE(MPIO_BUILD_PROFILING, 1, [hack to make ROMIO build without profiling])
|
|
DEFINE_HAVE_MPI_GREQUEST="#define HAVE_MPI_GREQUEST 1"
|
|
DEFINE_HAVE_MPI_GREQUEST_EXTENSIONS="#undef HAVE_MPI_GREQUEST_EXTENSIONS"
|
|
AC_DEFINE(HAVE_DECL_MPI_COMBINER_HINDEXED_BLOCK, 1, [Define if MPI library provides HINDEXED_BLOCK datatype])
|
|
AC_DEFINE(HAVE_MPIIO_CONST, 1, Set if MPI-IO prototypes use const qualifier)
|
|
elif test $FROM_LAM = yes ; then
|
|
# LAM does have the status set bytes functionality
|
|
AC_DEFINE(HAVE_STATUS_SET_BYTES,1,[Define if have MPIR_Status_set_bytes])
|
|
|
|
# Used in the tests/ subdirectory for after ROMIO is built
|
|
TEST_CC=mpicc
|
|
TEST_F77=mpifort
|
|
MPIRUN=mpirun
|
|
MPI_LIB=
|
|
ROMIO_INCLUDE=
|
|
USER_CFLAGS=
|
|
USER_FFLAGS=
|
|
TEST_LIBNAME=
|
|
EXTRA_DIRS="mpi-io/fortran mpi2-other/info mpi2-other/info/fortran mpi2-other/array mpi2-other/array/fortran"
|
|
elif test $FROM_MPICH = yes ; then
|
|
# For now, separate the mpich from mpich cases
|
|
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"
|
|
# To allow ROMIO to work with the LIBTOOL scripts, we want to
|
|
# work directly with the CC, not the mpicc, compiler.
|
|
# Note that in the "FROM_MPICH" case, the CPPFLAGS and INCLUDES are already
|
|
# properly set
|
|
#CC=${top_build_dir}/bin/mpicc
|
|
#
|
|
# set the compilers to the ones in MPICH bin directory (master_top_builddir/bin)
|
|
TEST_CC='$(bindir)/mpicc'
|
|
TEST_F77='$(bindir)/mpifort'
|
|
MPI_H_INCLUDE="-I${master_top_builddir}/src/include"
|
|
ROMIO_INCLUDE=""
|
|
USER_CFLAGS=""
|
|
USER_FFLAGS=""
|
|
TEST_LIBNAME=""
|
|
MPIRUN='${bindir}/mpiexec'
|
|
#
|
|
# Turn off the building of the Fortran interface and the Info routines
|
|
EXTRA_DIRS=""
|
|
AC_DEFINE(HAVE_STATUS_SET_BYTES,1,[Define if status_set_bytes available])
|
|
DEFINE_HAVE_MPI_GREQUEST="#define HAVE_MPI_GREQUEST 1"
|
|
DEFINE_HAVE_MPI_GREQUEST_EXTENSIONS="#define HAVE_MPI_GREQUEST_EXTENSIONS 1"
|
|
AC_DEFINE(HAVE_MPIU_FUNCS,1,[Define if MPICH memory tracing macros defined])
|
|
AC_DEFINE(HAVE_MPIX_H, 1, [])
|
|
AC_DEFINE(HAVE_MPIIO_CONST, 1, Set if MPI-IO prototypes use const qualifier)
|
|
AC_DEFINE(HAVE_MPI_TYPE_SIZE_X, 1, [Define if MPI library provides MPI_TYPE_SIZE_X])
|
|
AC_DEFINE(HAVE_MPI_STATUS_SET_ELEMENTS_X, 1, [Define if MPI library provides MPI_STATUS_SET_ELEMENTS_X])
|
|
AC_DEFINE(HAVE_DECL_MPI_COMBINER_HINDEXED_BLOCK, 1, [Define if MPI library provides HINDEXED_BLOCK datatype])
|
|
fi
|
|
#
|
|
#
|
|
# feature tests: we can't test features if building as part of MPICH because
|
|
# we don't yet have an implementation against which we can test
|
|
#
|
|
if test $WITHIN_KNOWN_MPI_IMPL = no ; then
|
|
PAC_TEST_MPIR_STATUS_SET_BYTES
|
|
PAC_TEST_MPI_GREQUEST
|
|
PAC_TEST_MPIU_FUNCS
|
|
AC_DEFINE(PRINT_ERR_MSG,1,[Define for printing error messages])
|
|
AC_CHECK_TYPE(MPI_Count,[],[AC_DEFINE_UNQUOTED([MPI_Count],[MPI_Aint],[Define to "MPI_Aint" if MPI does not provide MPI_Count]) ])
|
|
PAC_TEST_NEEDS_CONST
|
|
AC_CHECK_DECLS([MPI_COMBINER_HINDEXED_BLOCK], [], [], [[#include <mpi.h>]])
|
|
AC_CHECK_FUNCS(MPI_Type_size_x MPI_Status_set_elements_x)
|
|
fi
|
|
#
|
|
if test -z "$TEST_CC" ; then
|
|
TEST_CC="$CC"
|
|
fi
|
|
if test -z "$TEST_F77" ; then
|
|
TEST_F77="$F77"
|
|
fi
|
|
#
|
|
AC_CHECK_FUNCS(strdup)
|
|
if test "$ac_cv_func_strdup" = "yes" ; then
|
|
# Do we need to declare strdup?
|
|
PAC_FUNC_NEEDS_DECL([#include <string.h>],strdup)
|
|
fi
|
|
AC_CHECK_FUNCS(snprintf)
|
|
if test "$ac_cv_func_snprintf" = "yes" ; then
|
|
# Do we need to declare snprintf?
|
|
PAC_FUNC_NEEDS_DECL([#include <stdio.h>],snprintf)
|
|
fi
|
|
AC_CHECK_FUNCS(lstat)
|
|
if test "$ac_cv_func_lstat" = "yes" ; then
|
|
# Do we need to declare lstat?
|
|
PAC_FUNC_NEEDS_DECL([#include <unistd.h>
|
|
#include <sys/stat.h>],lstat)
|
|
fi
|
|
AC_CHECK_FUNCS(readlink)
|
|
if test "$ac_cv_func_readlink" = "yes" ; then
|
|
# Do we need to declare readlink?
|
|
PAC_FUNC_NEEDS_DECL([#include <unistd.h>],readlink)
|
|
fi
|
|
AC_CHECK_FUNCS(fsync)
|
|
if test "$ac_cv_func_fsync" = "yes" ; then
|
|
# Do we need to declare fsync?
|
|
PAC_FUNC_NEEDS_DECL([#include <unistd.h>],fsync)
|
|
fi
|
|
AC_CHECK_FUNCS(ftruncate)
|
|
if test "$ac_cv_func_ftruncate" = "yes" ; then
|
|
# Do we need to declare ftruncate?
|
|
PAC_FUNC_NEEDS_DECL([#include <unistd.h>],ftruncate)
|
|
fi
|
|
|
|
AC_CHECK_FUNCS(lseek64)
|
|
if test "$ac_cv_func_lseek64" = "yes" ; then
|
|
PAC_FUNC_NEEDS_DECL([#include <unistd.h>],lseek64)
|
|
fi
|
|
|
|
AC_CHECK_FUNCS(usleep)
|
|
if test "$ac_cv_func_usleep" = "yes" ; then
|
|
PAC_FUNC_NEEDS_DECL([#include <unistd.h>],usleep)
|
|
fi
|
|
|
|
#
|
|
# Create the directory lists for the Makefile
|
|
FILE_SYS_DIRS=""
|
|
for dir in $FILE_SYSTEM ; do
|
|
FILE_SYS_DIRS="$FILE_SYS_DIRS adio/ad_$dir"
|
|
done
|
|
# FIXME eliminate FILE_SYS_DIRS and EXTRA_SRC_DIRS
|
|
EXTRA_SRC_DIRS=""
|
|
|
|
mpio_glue=""
|
|
if test "$FROM_MPICH" = yes -o "${MPI_IMPL}_mpi" = "mpich_mpi"; then
|
|
mpio_glue=mpich
|
|
elif test "$FROM_OMPI" = yes -o "${MPI_IMPL}_mpi" = "open_mpi_mpi" ; then
|
|
mpio_glue=openmpi
|
|
else
|
|
mpio_glue=default
|
|
fi
|
|
|
|
AM_CONDITIONAL([MPIO_GLUE_MPICH],[test "X$mpio_glue" = "Xmpich"])
|
|
AM_CONDITIONAL([MPIO_GLUE_OPENMPI],[test "X$mpio_glue" = "Xopenmpi"])
|
|
AM_CONDITIONAL([MPIO_GLUE_DEFAULT],[test "X$mpio_glue" = "Xdefault"])
|
|
|
|
if test "$BUILD_MPI_INFO" = 1 ; then
|
|
EXTRA_SRC_DIRS="$EXTRA_SRC_DIRS mpi2-other/info"
|
|
if test "$NOF77" = 0 -a "$FROM_MPICH" != yes ; then
|
|
EXTRA_SRC_DIRS="$EXTRA_SRC_DIRS mpi2-other/info/fortran"
|
|
fi
|
|
fi
|
|
if test "$BUILD_MPI_ARRAY" = 1 ; then
|
|
EXTRA_SRC_DIRS="$EXTRA_SRC_DIRS mpi2-other/array"
|
|
if test "$NOF77" = 0 -a "$FROM_MPICH" != yes ; then
|
|
EXTRA_SRC_DIRS="$EXTRA_SRC_DIRS mpi2-other/array/fortran"
|
|
fi
|
|
fi
|
|
if test "$NOF77" = 0 -a "$FROM_MPICH" != yes ; then
|
|
EXTRA_SRC_DIRS="$EXTRA_SRC_DIRS mpi-io/fortran"
|
|
fi
|
|
AC_SUBST(EXTRA_SRC_DIRS)
|
|
AC_SUBST(FILE_SYS_DIRS)
|
|
|
|
#
|
|
CFLAGS="$CFLAGS -DHAVE_ROMIOCONF_H"
|
|
#
|
|
|
|
if test -n "$MPIOF_H_INCLUDED"; then
|
|
F77MPIOINC=""
|
|
else
|
|
F77MPIOINC="include 'mpiof.h'"
|
|
fi
|
|
|
|
AC_CHECK_HEADERS(unistd.h,
|
|
AC_MSG_CHECKING([for large file defines])
|
|
AC_TRY_COMPILE([
|
|
#include <unistd.h>
|
|
], [
|
|
#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) )
|
|
)
|
|
|
|
echo "setting SYSDEP_INC to $SYSDEP_INC"
|
|
AC_SUBST(SYSDEP_INC)
|
|
|
|
# Open MPI: use the exact same restrict test that we use in the
|
|
# upper-level Open MPI configure script so that we always get the same
|
|
# #define for "restrict" (there are a small number of files that will
|
|
# end up including both ROMIO's romioconf.h and opal_config.h, so we
|
|
# need to #defines to agree).
|
|
AC_C_RESTRICT
|
|
PAC_C_GNU_ATTRIBUTE
|
|
|
|
# Open MPI: we need libtool
|
|
AM_PROG_LIBTOOL
|
|
|
|
# Open MPI: setup the AM_CONDITIONALs to build the different adio devices
|
|
m4_foreach([my_fs],
|
|
[gpfs, gridftp, hfs, lustre, nfs, ntfs, panfs, pfs, pvfs, piofs, pvfs, pvfs2, sfs, testfs, ufs, xfs, zoidfs],
|
|
[AM_CONDITIONAL(BUILD_[]AS_TR_CPP(my_fs), [test -n "$file_system_]my_fs["])])
|
|
|
|
# support gcov test coverage information
|
|
PAC_ENABLE_COVERAGE
|
|
|
|
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"
|
|
|
|
# Open MPI: Add on CFLAGS that we figured out up top. They have
|
|
# makefile macros in them, so we couldn't substitute them until now.
|
|
CFLAGS="$CFLAGS $OMPI_CFLAGS "'-I$(top_builddir)/include'
|
|
#
|
|
# Open MPI - AM doesn't want the following:
|
|
# VPATH, CC, CPPFLAGS, CFLAGS, AR, RANLIB, F77, MAKE
|
|
AC_SUBST(ARCH)
|
|
AC_SUBST(FILE_SYSTEM)
|
|
#AC_SUBST(CC)
|
|
#AC_SUBST(CPPFLAGS)
|
|
#AC_SUBST(CFLAGS)
|
|
AC_SUBST(USER_CFLAGS)
|
|
AC_SUBST(USER_FFLAGS)
|
|
AC_SUBST(MIPS)
|
|
AC_SUBST(BITS)
|
|
#AC_SUBST(AR)
|
|
AC_SUBST(AR_FLAGS)
|
|
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(F77MPIOINC)
|
|
AC_SUBST(FTESTDEFINE)
|
|
AC_SUBST(FORTRAN_MPI_OFFSET)
|
|
AC_SUBST(FROM_MPICH)
|
|
AC_SUBST(FROM_LAM)
|
|
AC_SUBST(WITHIN_KNOWN_MPI_IMPL)
|
|
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(DEFINE_HAVE_MPI_GREQUEST)
|
|
AC_SUBST(MPI_OFFSET_TYPE)
|
|
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_TCFLAGS)
|
|
AC_SUBST(ROMIO_TCPPFLAGS)
|
|
AC_SUBST(ROMIO_TFFLAGS)
|
|
AC_SUBST(MPIRUN)
|
|
AC_SUBST(FORTRAN_TEST)
|
|
#dnl
|
|
#dnl Support shared libraries
|
|
#if test -z "$ENABLE_SHLIB" ; then
|
|
# ENABLE_SHLIB=none
|
|
#fi
|
|
#AC_SUBST(ENABLE_SHLIB)
|
|
#AC_SUBST(CC_SHL)
|
|
#AC_SUBST(LIBTOOL)
|
|
# Open MPI: This is no longer necessary with modern versions of autotools
|
|
# Remove the .a from the library file name (so that we can use .so or
|
|
# other appropriate suffix)
|
|
#SHLIBNAME=`echo $LIBNAME | sed 's/\.a$//'`
|
|
#AC_SUBST(SHLIBNAME)
|
|
#dnl
|
|
#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
|
|
#if test ! -d mpi-io ; then mkdir mpi-io ; fi
|
|
#if test ! -d mpi-io/glue ; then mkdir mpi-io/glue ; fi
|
|
|
|
# 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_CONFIG_FILES([
|
|
Makefile
|
|
localdefs
|
|
test/Makefile
|
|
test/misc.c
|
|
test/large_file.c
|
|
test/runtests
|
|
test-internal/Makefile
|
|
util/romioinstall
|
|
include/mpio.h
|
|
test/fmisc.f
|
|
test/fcoll_test.f
|
|
test/pfcoll_test.f
|
|
test/fperf.f
|
|
])
|
|
# Open MPI: intentionally skip the following:
|
|
# mpi2-other/info/Makefile
|
|
# mpi2-other/array/Makefile
|
|
# mpi2-other/info/fortran/Makefile
|
|
# mpi2-other/array/fortran/Makefile
|
|
# include/mpiof.h
|
|
AC_OUTPUT
|
|
|
|
dnl PAC_SUBDIR_CACHE_CLEANUP
|
|
exit 0
|