root/mpich2/trunk/src/pm/hydra/configure.in @ 4860

AC_PREREQ(2.62)
#
# (C) 2008 by Argonne National Laboratory.
#     See COPYRIGHT in top-level directory.
#

AC_INIT([Hydra], [0.1])
AC_CONFIG_AUX_DIR(mpl/confdb)
AM_INIT_AUTOMAKE([-Wall -Werror foreign 1.11])

dnl When built as a subconfigure, pull in FLAGS from above
PAC_SUBCONFIG_INIT()

AC_CONFIG_HEADER(include/hydra_config.h)

# Check for special types
AC_TYPE_SIZE_T

dnl Bug in autoconf adds -O2 and -g by default. Make sure we only get
dnl the flags we want.
save_cflags=$CFLAGS
AC_PROG_CC
CFLAGS=$save_cflags

AM_PROG_MKDIR_P
AC_PROG_RANLIB
PAC_ARG_CACHING
PAC_ARG_STRICT
PAC_C_GNU_ATTRIBUTE
PAC_CC_FUNCTION_NAME_SYMBOL

dnl Check if the necessary headers are available
AC_CHECK_HEADERS(unistd.h stdlib.h string.h strings.h stdarg.h sys/types.h sys/socket.h \
                 sched.h pthread.h sys/stat.h sys/param.h netinet/in.h netinet/tcp.h \
                 sys/un.h netdb.h)

dnl Check if the pthread library is present. Apparently, just checking
dnl for pthread.h is not sufficient.
AC_CHECK_LIB(pthread,pthread_create,pthread_lib_exists=yes,pthread_lib_exists=no)

dnl Check if the upper-level enabled threads support
if test "$MPICH2_THREAD_PACKAGE" != "none" -a "$pthread_lib_exists" = "yes" ; then
   AC_DEFINE(HAVE_THREAD_SUPPORT,1,[Define thread support])
   LDFLAGS="$LDFLAGS -lpthread"
fi

AC_SEARCH_LIBS(socket,socket,LDFLAGS="$LDFLAGS -lsocket",)
AC_SEARCH_LIBS(gethostbyname,nsl,LDFLAGS="$LDFLAGS -lnsl",)

dnl Check for necessary functions
AC_CHECK_FUNCS(gettimeofday time strdup sigaction signal usleep alloca unsetenv \
               strerror strsignal putenv)

# putenv() sets environment variable
AC_HAVE_FUNCS(putenv)
if test "$ac_cv_func_putenv" = "yes" ; then
    PAC_FUNC_NEEDS_DECL([#include <stdlib.h>],putenv)
fi

dnl Check what we need to do about the environ extern
AC_CACHE_CHECK([for environ in unistd.h],pac_cv_environ_in_unistd,
        [AC_TRY_COMPILE([#include <unistd.h>],[char **x = environ;],
        pac_cv_environ_in_unistd=yes,pac_cv_environ_in_unistd=no)])
if test "$pac_cv_environ_in_unistd" = "yes" ; then
    # We have environ defined in unistd.h; we are done
    AC_DEFINE(HAVE_EXTERN_ENVIRON,1,[Define if environ extern is available])
else
    # See if we can declare it
    AC_CACHE_CHECK([for manually declared extern environ], pac_cv_manual_extern_environ,
        [AC_TRY_LINK([#include <unistd.h>],[extern char ** environ; char **x = environ;],
        pac_cv_manual_extern_environ=yes,pac_cv_manual_extern_environ=no)])
    if test "$pac_cv_manual_extern_environ" = "yes" ; then
        # We can manually declare the extern
        AC_DEFINE(MANUAL_EXTERN_ENVIRON,1,[Define if environ decl needed])
        AC_DEFINE(HAVE_EXTERN_ENVIRON,1,[Define if environ extern is available])
    fi
fi

dnl Check what boot-strap server we should use
AC_ARG_WITH(hydra-bss, [  --with-hydra-bss           Boot-strap Server],
                    [ hydra_bss=$withval ],
                    [ hydra_bss="ssh,rsh,fork,slurm" ])
AC_MSG_CHECKING(boot-strap server)
AC_MSG_RESULT($hydra_bss)
hydra_bss_names="`echo $hydra_bss | sed -e 's/:/ /g' -e 's/,/ /g'`"
AC_DEFINE_UNQUOTED(HYDRA_BSS_NAMES,"$hydra_bss_names",[Definition of enabled bootstrap servers])
AM_SUBST_NOTMAKE(hydra_bss_names)
AC_SUBST(hydra_bss_names)

hydra_bss_ssh=false
hydra_bss_rsh=false
hydra_bss_fork=false
hydra_bss_slurm=false
for hydra_bss_name in ${hydra_bss_names}; do
    if test -z "${hydra_default_bss}" ; then
       hydra_default_bss=$hydra_bss_name
    fi
    hydra_bss_makefiles="$hydra_bss_makefiles bootstrap/${hydra_bss_name}/Makefile"
    hydra_bss_init_decl="${hydra_bss_init_decl}
HYD_Status HYD_BSCI_${hydra_bss_name}_init(void);"
    hydra_bss_name_array="${hydra_bss_name_array} \"${hydra_bss_name}\", "
    hydra_bss_init_array="${hydra_bss_init_array} HYD_BSCI_${hydra_bss_name}_init, "

    case "$hydra_bss_name" in
        ssh)
                hydra_bss_ssh=true
                ;;              
        rsh)
                hydra_bss_rsh=true
                ;;
        fork)
                hydra_bss_fork=true
                ;;
        slurm)
                hydra_bss_slurm=true
                ;;
        *)
                ;;
    esac

done
hydra_bss_name_array="${hydra_bss_name_array} NULL"
hydra_bss_init_array="${hydra_bss_init_array} NULL"
AC_DEFINE_UNQUOTED(HYDRA_DEFAULT_BSS,"$hydra_default_bss",[Default bootstrap server])
AM_SUBST_NOTMAKE(hydra_bss_init_decl)
AM_SUBST_NOTMAKE(hydra_bss_name_array)
AM_SUBST_NOTMAKE(hydra_bss_init_array)
AC_SUBST(hydra_bss_init_decl)
AC_SUBST(hydra_bss_name_array)
AC_SUBST(hydra_bss_init_array)
AM_CONDITIONAL([hydra_bss_ssh], [$hydra_bss_ssh])
AM_CONDITIONAL([hydra_bss_rsh], [$hydra_bss_rsh])
AM_CONDITIONAL([hydra_bss_fork], [$hydra_bss_fork])
AM_CONDITIONAL([hydra_bss_slurm], [$hydra_bss_slurm])


dnl Check what communication sub-system we should use
AC_ARG_WITH(hydra-css, [  --with-hydra-css           Communication Sub-system],
                    [ hydra_css=$withval ],
                    [ hydra_css="none" ])
AC_MSG_CHECKING(communication subsystem)
AC_MSG_RESULT($hydra_css)
hydra_css_names="`echo $hydra_css | sed -e 's/:/ /g' -e 's/,/ /g'`"
AC_DEFINE_UNQUOTED(HYDRA_CSS_NAMES,"$hydra_css_names",[Definition of enabled communication systems])
AM_SUBST_NOTMAKE(hydra_css_names)
AC_SUBST(hydra_css_names)

hydra_css_none=false
for hydra_css_name in ${hydra_css_names}; do
    if test -z "${hydra_default_css}" ; then
       hydra_default_css=$hydra_css_name
    fi
    hydra_css_makefiles="$hydra_css_makefiles css/${hydra_css_name}/Makefile"
    hydra_css_init_decl="${hydra_css_init_decl}
HYD_Status HYD_CSSI_${hydra_css_name}_init(void);"
    hydra_css_name_array="${hydra_css_name_array} \"${hydra_css_name}\", "
    hydra_css_init_array="${hydra_css_init_array} HYD_CSSI_${hydra_css_name}_init, "

    case "$hydra_css_name" in
        dummy)
                hydra_css_none=true
                ;;              
        *)
                ;;
    esac

done
hydra_css_name_array="${hydra_css_name_array} NULL"
hydra_css_init_array="${hydra_css_init_array} NULL"
AC_DEFINE_UNQUOTED(HYDRA_DEFAULT_CSS,"$hydra_default_css",[Default communication sub-system])
AM_SUBST_NOTMAKE(hydra_css_init_decl)
AM_SUBST_NOTMAKE(hydra_css_name_array)
AM_SUBST_NOTMAKE(hydra_css_init_array)
AC_SUBST(hydra_css_init_decl)
AC_SUBST(hydra_css_name_array)
AC_SUBST(hydra_css_init_array)
AM_CONDITIONAL([hydra_css_none], [$hydra_css_none])


dnl Check what resource management kernel we should use
AC_ARG_WITH(hydra-rmk, [  --with-hydra-rmk        Resource Management Kernel],
                    [ hydra_rmk=$withval ],
                    [ hydra_rmk="dummy" ])
AC_MSG_CHECKING(resource management kernel)
AC_MSG_RESULT($hydra_rmk)
hydra_rmk_names="`echo $hydra_rmk | sed -e 's/:/ /g' -e 's/,/ /g'`"
AC_DEFINE_UNQUOTED(HYDRA_RMK_NAMES,"$hydra_rmk_names",[Enabled resource management kernels])
AM_SUBST_NOTMAKE(hydra_rmk_names)
AC_SUBST(hydra_rmk_names)

hydra_rmk_dummy=false
for hydra_rmk_name in ${hydra_rmk_names}; do
    if test -z "${hydra_default_rmk}" ; then
       hydra_default_rmk=$hydra_rmk_name
    fi
    hydra_rmk_makefiles="$hydra_rmk_makefiles rmk/${hydra_rmk_name}/Makefile"
    hydra_rmk_init_decl="${hydra_rmk_init_decl}
HYD_Status HYD_RMKI_${hydra_rmk_name}_init(void);"
    hydra_rmk_name_array="${hydra_rmk_name_array} \"${hydra_rmk_name}\", "
    hydra_rmk_init_array="${hydra_rmk_init_array} HYD_RMKI_${hydra_rmk_name}_init, "

    case "$hydra_rmk_name" in
        dummy)
                hydra_rmk_dummy=true
                ;;              
        *)
                ;;
    esac

done
hydra_rmk_name_array="${hydra_rmk_name_array} NULL"
hydra_rmk_init_array="${hydra_rmk_init_array} NULL"
AC_DEFINE_UNQUOTED(HYDRA_DEFAULT_RMK,"$hydra_default_rmk",[Default resource management kernel])
AM_SUBST_NOTMAKE(hydra_rmk_init_decl)
AM_SUBST_NOTMAKE(hydra_rmk_name_array)
AM_SUBST_NOTMAKE(hydra_rmk_init_array)
AC_SUBST(hydra_rmk_init_decl)
AC_SUBST(hydra_rmk_name_array)
AC_SUBST(hydra_rmk_init_array)
AM_CONDITIONAL([hydra_rmk_dummy], [$hydra_rmk_dummy])


dnl Check what process manager we should use
AC_ARG_WITH(hydra-pm, [  --with-hydra-pm               Process Manager],
                [ hydra_pm=$withval ],
                [ hydra_pm=pmiserv ])
AC_MSG_CHECKING(process manager)
AC_MSG_RESULT($hydra_pm)
AC_SUBST(hydra_pm)
AM_CONDITIONAL([hydra_pm_pmiserv], [test $hydra_pm = "pmiserv"])


dnl Check what UI we should use
AC_ARG_WITH(hydra-ui, [  --with-hydra-ui         User Interface],
                [ hydra_ui=$withval ],
                [ hydra_ui=mpiexec ])
AC_MSG_CHECKING(user interface)
AC_MSG_RESULT($hydra_ui)
AC_SUBST(hydra_ui)
AM_CONDITIONAL([hydra_ui_mpiexec], [test $hydra_ui = "mpiexec"])

dnl Check what communication sub-system we should use
AC_ARG_WITH(hydra-css, [  --with-hydra-css               Communication Sub-system],
                [ hydra_css=$withval ],
                [ hydra_css= ])
AC_MSG_CHECKING(communication subsystem)
if test "x$hydra_css" != "x" ; then
   AC_MSG_RESULT($hydra_css)
else
   AC_MSG_RESULT(none)
fi
AC_SUBST(hydra_css)

dnl Debugging support
AC_ARG_ENABLE(g, [  --enable-g              Enable Debugging],
                 [ DEBUG=$enableval ],
                 [ DEBUG=no ])
AC_MSG_CHECKING(debugging support)
AC_MSG_RESULT($DEBUG)
if test "$DEBUG" = "yes"; then
   EXTRA_CFLAGS="$EXTRA_CFLAGS -g"
   AC_DEFINE(ENABLE_DEBUG,1,[Define if debugging support is enabled])
fi
AC_SUBST(EXTRA_CFLAGS)

dnl Warning messages
AC_ARG_ENABLE(warnings, [  --enable-warnings              Enable warnings],
                        [ WARNINGS=$enableval ],
                        [ WARNINGS=no ])
AC_MSG_CHECKING(warnings)
AC_MSG_RESULT($WARNINGS)
if test "$WARNINGS" = "yes"; then
   AC_DEFINE(ENABLE_WARNINGS,1,[Define if warnings are enabled])
fi

dnl Process Binding
AC_ARG_ENABLE(hydra-procbind, [  --enable-hydra-procbind       Process Binding],
                              [ procbind=$enableval ],
                              [ procbind=auto ])
AC_MSG_CHECKING(process binding)

if test "$procbind" = "auto" ; then
   old_CFLAGS=$CFLAGS
   CFLAGS="$CFLAGS -I${srcdir}/utils/plpa"
   AC_TRY_LINK([#include <plpa_internal.h>],[
PLPA_NAME(api_type_t) p;
PLPA_NAME(api_probe)(&p);
],plpa_works=yes,plpa_works=no)
   CFLAGS=$old_CFLAGS
   if test "$plpa_works" = "yes" ; then
      procbind=yes
   else
      procbind=no
   fi
fi

AC_MSG_RESULT($procbind)
if test "$procbind" = "yes"; then
   AC_DEFINE(HAVE_PROC_BINDING,1,[Define if process binding is enabled])
   opt_utils_makefiles="${opt_utils_makefiles} utils/plpa/Makefile utils/bind/Makefile"
   opt_utils="${opt_utils} plpa bind"
fi
AM_CONDITIONAL([hydra_procbind], [test "${procbind}" = "yes"])
AC_SUBST(opt_utils)

dnl Check if __VA_ARGS__ is defined by the compiler
AC_MSG_CHECKING([whether the compiler allows __VA_ARGS__])
rm -f conftest.c
cat > conftest.c <<EOF
#include <stdio.h>
#define my_print(...) printf(__VA_ARGS__)
int main()
{
    my_print("woohoo!");
    return 0;
}
EOF
pac_tmp_compile='$CC $CFLAGS conftest.c -o conftest'
if AC_TRY_EVAL(pac_tmp_compile) && test -s conftest ; then
   AC_DEFINE(COMPILER_ACCEPTS_VA_ARGS,1,[Define if compiler supports __VA_ARGS__])
fi
rm -f conftest*

dnl Check for functions.  This invokes another test if the function is 
dnl found.  The braces around the second test are essential. 
dnl AC_CHECK_FUNC(setpgrp,[AC_FUNC_SETPGRP])
AC_CHECK_FUNCS(strsignal)
if test "$ac_cv_func_strsignal" = "yes" ; then
    PAC_FUNC_NEEDS_DECL([#include <string.h>],strsignal)
fi

dnl Check for signal handlers
AC_CHECK_FUNCS(sigaction signal sigset)
sigaction_ok=no
if test "$ac_cv_func_sigaction" = "yes" ; then
    # Make sure that the fields that we need in sigaction are defined
    AC_CACHE_CHECK([for struct sigaction and sa_handler],
    pac_cv_struct_sigaction_with_sa_handler,[
    AC_TRY_COMPILE([#include <signal.h>],[
struct sigaction act; sigaddset( &act.sa_mask, SIGINT );
act.sa_handler = SIG_IGN;],
    pac_cv_struct_sigaction_with_sa_handler=yes,
    pac_cv_struct_sigaction_with_sa_handler=no)])
    if test "$pac_cv_struct_sigaction_with_sa_handler" = "no" ; then
        AC_CACHE_CHECK([for struct sigaction and sa_handler with _POSIX_SOURCE],
        pac_cv_struct_sigaction_with_sa_handler_needs_posix,[
        AC_TRY_COMPILE([#define _POSIX_SOURCE
#include <signal.h>],[
struct sigaction act; sigaddset( &act.sa_mask, SIGINT );
act.sa_handler = SIG_IGN;],
        pac_cv_struct_sigaction_with_sa_handler_needs_posix=yes,
        pac_cv_struct_sigaction_with_sa_handler_needs_posix=no)])
        if test "$pac_cv_struct_sigaction_with_sa_handler_needs_posix" = "yes" ; then
            sigaction_ok=yes
        fi
    else
        sigaction_ok=yes
    fi
fi

# Decide on the signal handler to use
if test "$ac_cv_func_sigaction" = "yes" -a "$sigaction_ok" = "yes" ; then
    if test "$pac_cv_struct_sigaction_with_sa_handler_needs_posix" = yes ; then
        AC_DEFINE(NEEDS_POSIX_FOR_SIGACTION,1,[Define if _POSIX_SOURCE needed to get sigaction])
    fi
    AC_DEFINE(USE_SIGACTION,,[Define if sigaction should be used to set signals])
elif test "$ac_cv_func_signal" = "yes" ; then
    AC_DEFINE(USE_SIGNAL,,[Define if signal should be used to set signals])
fi

# gethostname() returns host name
AC_CHECK_FUNCS(gethostname)
if test "$ac_cv_func_gethostname" = "yes" ; then
    # Do we need to declare gethostname?
    PAC_FUNC_NEEDS_DECL([#include <unistd.h>],gethostname)
fi

dnl Substitute common variables. Some versions of autoconf have
dnl trouble with this.
AC_SUBST(CC)
AC_SUBST(CFLAGS)
AC_SUBST(LDFLAGS)
AC_SUBST(CC_SHL)
AC_SUBST(C_LINK_SHL)

ENABLE_SHLIB=none
AC_SUBST(ENABLE_SHLIB)
AC_SUBST(RANLIB)
AC_SUBST(MAKE_DEPEND_C)

AC_PROG_INSTALL

AC_CONFIG_SUBDIRS(mpl)

dnl Place holder macro for finalization
PAC_SUBCONFIG_FINALIZE()

dnl Final output
AC_OUTPUT(Makefile
        bootstrap/src/bsci_init.c
        bootstrap/include/bsci.h
        rmk/src/rmki_init.c
        rmk/include/rmki.h
        css/src/cssi_init.c
        css/include/cssi.h
)