AC_PREREQ(2.63)

#

# (C) 2006 by Argonne National Laboratory.

#     See COPYRIGHT in top-level directory.

#

AC_INIT([MPL], [0.1])

# sanity check that --srcdir was specified correctly

AC_CONFIG_SRCDIR([src/str/mpl_str.c])

AC_CONFIG_AUX_DIR(confdb)

AC_CONFIG_MACRO_DIR(confdb)

AM_INIT_AUTOMAKE([subdir-objects] [-Wall -Werror foreign 1.12.3])

dnl must come before LT_INIT, which AC_REQUIREs AC_PROG_CC

PAC_PROG_CC

AM_PROG_CC_C_O

AC_USE_SYSTEM_EXTENSIONS

AM_PROG_AR

LT_PREREQ([2.2.6])

# Bug in libtool adds -O2 and -g by default

PAC_PUSH_FLAG([CFLAGS])

LT_INIT()

PAC_POP_FLAG([CFLAGS])

# ----------------------------------------------------------------------------

# Set default library names if names haven't already been provided

AC_ARG_VAR([MPLLIBNAME],[can be used to override the name of the MPL library (default: "mpl")])

MPLLIBNAME=${MPLLIBNAME:-"mpl"}

AC_SUBST(MPLLIBNAME)

export MPLLIBNAME

if test -s "$srcdir/VERSION" ; then

   . $srcdir/VERSION

   AC_SUBST(libmpl_so_version)

else

   AC_MSG_ERROR([Version information not found. Configuration aborted.])

fi

AC_CONFIG_HEADER([include/config.h])

AC_CONFIG_COMMANDS([prefix-config],[perl $srcdir/confdb/cmd_prefix_config_h.pl MPL include/config.h include/mplconfig.h])

# Non-verbose make

m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES([yes])])

AC_C_CONST

AC_C_RESTRICT

AC_C_INLINE

PAC_C_MACRO_VA_ARGS

PAC_C_BUILTIN_EXPECT

AC_ARG_ENABLE(embedded,

    AC_HELP_STRING([--enable-embedded], [Build MPL in embedded mode (default is no)]),

    [embedded=yes],

    [embedded=no])

AM_CONDITIONAL([MPL_EMBEDDED_MODE],[test "x${embedded}" = "xyes"])

AC_ARG_ENABLE(g,

    AC_HELP_STRING([--enable-g=option],

	[

		Control the level of debugging support in MPL.

		"option" is a list of comma separated names.  Default

		is "all".

	    none|no   - No debugging

	    log       - Enable debug event logging

	    mem       - Enable memory tracing

	    yes|all   - All of the above choices (except "none", obviously)

	]),,[enable_g=none])

# enable-g

# strip off multiple options, separated by commas

PAC_PUSH_FLAG(IFS)

IFS=","

for option in $enable_g ; do

    case "$option" in

	 log)

	 enable_g_log=yes

	 ;;

	 mem)

	 enable_g_mem=yes

	 ;;

	 all|yes)

	 enable_g_log=yes

	 enable_g_mem=yes

	 ;;

	 no|none)

	 ;;

	 *)

	 AC_MSG_WARN([Unknown value $option for enable-g])

	 ;;

    esac

done

PAC_POP_FLAG(IFS)

if test "$enable_g_log" = "yes" ; then

   AC_DEFINE([USE_DBG_LOGGING],[1],[Define to enable logging macros])

fi

if test "$enable_g_mem" = "yes" ; then

   AC_DEFINE([USE_MEMORY_TRACING],[1],[Define to enable memory tracing])

fi

# support gcov test coverage information

PAC_ENABLE_COVERAGE

# check for compiler support for the __typeof() extension

AC_CACHE_CHECK([whether the compiler supports __typeof(variable)],

               [pac_cv_have___typeof],

[AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]],[[double foo = 0.0; __typeof(foo) bar = 1.0;]])],

                  [pac_cv_have___typeof=yes],

                  [pac_cv_have___typeof=no])]

)

if test "$pac_cv_have___typeof" = "yes" ; then

    AC_DEFINE([HAVE___TYPEOF],[1],[defined if the C compiler supports __typeof(variable)])

fi

dnl Check if the necessary headers are available

AC_CHECK_HEADERS(stdio.h stdlib.h string.h stdarg.h ctype.h sys/types.h sys/uio.h execinfo.h unistd.h errno.h windows.h sys/mman.h)

# A C99 compliant compiler should have inttypes.h for fixed-size int types

AC_CHECK_HEADERS(inttypes.h stdint.h)

AC_HEADER_STDBOOL

#######################################################################

# valgrind support

AC_ARG_WITH([valgrind],

[AS_HELP_STRING([--without-valgrind],[to disable valgrind support (such as because of version issues)])]

[AS_HELP_STRING([--with-valgrind=PATH],[use valgrind headers installed in PATH (default is "yes", use no special path)])],

[],[with_valgrind=yes])

if test "$with_valgrind" != "no" ; then

    savedCPPFLAGS="$CPPFLAGS"

    if test "$with_valgrind" != "yes" ; then

        # Clients of MPL will either need to respect the localdefs file (as in

        # MPICH) or add this entry to their own CPPFLAGS-equivalent.

        # (TODO: a pkg-config file would help with this)

        PAC_APPEND_FLAG([-I${with_valgrind}], [CPPFLAGS])

    fi

    # headers for valgrind client requests

    AC_CHECK_HEADERS([valgrind.h memcheck.h valgrind/valgrind.h valgrind/memcheck.h])

    # headers for valgrind-based thread checking tools

    # TODO: incorporate ThreadSanitizer as well (include dynamic_annotations.h,

    # link with dynamic_annotations.c)

    AC_CHECK_HEADERS([helgrind.h valgrind/helgrind.h])

    AC_CHECK_HEADERS([drd.h valgrind/drd.h])

    # ensure that we have a new enough valgrind with all the client macros

    # a preproc test would probably be sufficient, but the LINK_IFELSE helps us

    # double-check that we aren't accidentally grabbing the headers for some

    # other platform

    AC_CACHE_CHECK([whether the valgrind headers are broken or too old],

                   [pac_cv_have_broken_valgrind],

                   [AC_LINK_IFELSE(

                       [AC_LANG_PROGRAM([

#if defined(HAVE_VALGRIND_H) && defined(HAVE_MEMCHECK_H)

#  include <valgrind.h>

#  include <memcheck.h>

#elif defined(HAVE_VALGRIND_VALGRIND_H) && defined(HAVE_VALGRIND_MEMCHECK_H)

#  include <valgrind/valgrind.h>

#  include <valgrind/memcheck.h>

#else

#  error unexpected valgrind header error

#endif

int foo = 10;

char mempool_obj;

],[

#if defined(VALGRIND_MAKE_MEM_DEFINED)

    VALGRIND_MAKE_MEM_NOACCESS(&foo,sizeof(foo));

    VALGRIND_MAKE_MEM_UNDEFINED(&foo,sizeof(foo));

    VALGRIND_MAKE_MEM_DEFINED(&foo,sizeof(foo));

    VALGRIND_CHECK_MEM_IS_DEFINED(&foo,sizeof(foo));

    VALGRIND_CHECK_MEM_IS_ADDRESSABLE(&foo,sizeof(foo));

#elif defined(VALGRIND_MAKE_READABLE)

/* older (pre-3.2.0), but still supported style */

    VALGRIND_MAKE_READABLE(&foo,sizeof(foo));

    VALGRIND_MAKE_NOACCESS(&foo,sizeof(foo));

    VALGRIND_MAKE_UNDEFINED(&foo,sizeof(foo));

    VALGRIND_CHECK_READABLE(&foo,sizeof(foo));

    VALGRIND_CHECK_WRITEABLE(&foo,sizeof(foo));

#else

#error missing essential valgrind client macros

#endif

    VALGRIND_CREATE_BLOCK(&foo,sizeof(foo),"description");

    if (RUNNING_ON_VALGRIND) ++foo;

    VALGRIND_PRINTF_BACKTRACE("testing: %s","valgrind support");

    VALGRIND_CREATE_MEMPOOL(&mempool_obj,0,0);

    VALGRIND_MEMPOOL_ALLOC(&mempool_obj,&foo,sizeof(foo));

    VALGRIND_MEMPOOL_FREE(&mempool_obj,&foo;;

    VALGRIND_DESTROY_MEMPOOL(&mempool_obj);

]) dnl end PROGRAM

                       ],

                       [pac_cv_have_broken_valgrind=no], dnl end if-true

                       [pac_cv_have_broken_valgrind=yes] dnl end if-false

                   )] dnl end IFELSE

                   ) dnl end CACHE_CHECK

    if test "$pac_cv_have_broken_valgrind" = "yes" ; then

        AC_DEFINE([HAVE_BROKEN_VALGRIND],[1],[define if valgrind is old and/or broken compared to what we are expecting])

        CPPFLAGS="$savedCPPFLAGS"

    fi

fi

#######################################################################

## TIMER CODE

#######################################################################

# ----------------------------------------------------------------------------

# Support for timers.  The following code processes the 

#  --enable-timer-type=name argument and selects the timer based on 

# both that field and what configure is able to determine is available.

# The file src/include/mpl_timer.h is also created.

# ----------------------------------------------------------------------------

# clock_gettime is the POSIX gettimeofday

# gethrtime is the Solaris high-resolution timer

dnl

dnl Specific checks that a function works correctly

dnl

dnl Now that we know what the options are, choose the timer to use

dnl

dnl The default preference is

dnl    Solaris gethrtime

dnl    Posix   clock_gettime

dnl    Unix    gettimeofday (one of two versions)

dnl

dnl Also available are various hardware time stamps

dnl    Linux-x86 cycle counter

dnl    Powerpc-64bit timebase cycle counter

dnl

dnl We also allow --enable-timer-type=name to select a timer type

AC_ARG_ENABLE(timer-type,

[  --enable-timer-type=name - Select the timer to use for MPI_Wtime and

                             internal timestamps.

        ppc64_cycle        - Powerpc-64bit; returns cycle counts using timebase register

        gethrtime          - Solaris timer (Solaris systems only)

        clock_gettime      - Posix timer (where available)

        gettimeofday       - Most Unix systems

        linux86_cycle      - Linux x86; returns cycle counts, not time in seconds*

        gcc_ia64_cycle     - IPF ar.itc timer*

	mach_absolute_time - Mach absolute time (alternative to clock_gettime

                             for OSX)

        device             - The timer is provided by the device

        *Note that the cycle timers are intended to be used by

        developers for internal low-level timing.  Normal users should

        not use these as they are not guaranteed to be accurate in

        certain situations.

],timer_type=$enable_timer_type)

## The user did not specify a timer type.  Try to find a sane option

## that is supported by the platform.

if test -z "$timer_type" ; then

    # Try to pick a timer based on what is available

    AC_CHECK_FUNCS(clock_gettime clock_getres gethrtime mach_absolute_time gettimeofday)

    if test "$ac_cv_func_gethrtime" = "yes" ; then

        # Sigh.  The Solaris include files do not define hrtime_t

	# Before we accept this choice, make sure that we can 

	# do arithmetic with hrtime_t .

        AC_CACHE_CHECK([that hrtime_t is properly defined for gethrtime],

	pac_cv_hrtime_works,[

	AC_TRY_COMPILE([

#include <sys/time.h>

],[hrtime_t t1, t2; t1 = 1; t2 = 2; t1 = t1 + t2;],

pac_cv_hrtime_works=yes,pac_cv_hrtime_works=no)])

	# A more ambitious test would look to see if casting an 

	# hrtime_t to int64_t works, and even more ambitious

	# would check whether long or long long was 64 bits (or even

	# better, the sizeof hrtime_t).  

        # AC_CHECK_FUNCS has false positive when checking whether gethrtime is

        # available on Solaris with strict configuration. We must use

        # AC_CHECK_DECL to confirm it.

        AC_CHECK_DECL(gethrtime)

    fi

    if test "$ac_cv_func_gethrtime" = "yes" -a \

            "$ac_cv_has_decl_gethrtime" = "yes" -a \

            "$pac_cv_hrtime_works" = "yes" ; then

        timer_type=gethrtime

    elif test "$ac_cv_func_clock_gettime" = "yes" -a \

              "$ac_cv_func_clock_getres" = "yes" ; then

	 # Test on both because some systems (e.g., cygwin) provide

	 # clock_gettime but not clock_getres

        timer_type=clock_gettime

    elif test "$ac_cv_func_mach_absolute_time" = "yes" ; then 

        timer_type=mach_absolute_time

    elif test "$ac_cv_func_gettimeofday" = "yes" ; then

        timer_type=gettimeofday

    fi

fi

if test -z "$timer_type" ; then

    AC_MSG_ERROR([No timer found])

fi

# Check for valid timer and select datatypes for the time stamp

case "$timer_type" in

    gethrtime)

    MPL_TIMER_TYPE=hrtime_t

    AC_CHECK_FUNC(gethrtime,,[

         AC_MSG_ERROR([Requested timer gethrtime is not available])

])

    ;;

    clock_gettime)

    missing_function=no

    AC_SEARCH_LIBS([clock_gettime],[rt],,AC_MSG_ERROR([clock_gettime is not available]))

    AC_SEARCH_LIBS([clock_getres],[rt],,AC_MSG_ERROR([clock_getres is not available]))

    MPL_TIMER_TYPE="struct timespec"

    # AIX does not always define struct timespec (!)

    # Make sure that we can use struct timespec

    AC_CACHE_CHECK([whether struct timespec is defined in time.h],

                    pac_cv_struct_timespec_defined,[

    AC_TRY_COMPILE([

#include <time.h>],[

    struct timespec t;],pac_cv_struct_timespec_defined=yes,

    pac_cv_struct_timespec_defined=no)

])

    if test "$pac_cv_struct_timespec_defined" != "yes" ; then

        # Try again, but with -D_XOPEN_SOURCE=500 (works for AIX)

        AC_CACHE_CHECK([whether struct timespec is defined in time.h with _XOPEN_SOURCE=500],

                    pac_cv_struct_timespec_defined_with_xopen500,[

        AC_TRY_COMPILE([

#define _XOPEN_SOURCE 500

#include <time.h>],[

    struct timespec t;],pac_cv_struct_timespec_defined_with_xopen500=yes,

    pac_cv_struct_timespec_defined_with_xopen500=no)

])

	if test "$pac_cv_struct_timespec_defined_with_xopen500" = "yes" ; then

	    # We need to define _XOPEN_SOURCE=500, but we need to ensure that

	    # this is done before any include files are loaded.  At

	    # this point it is really too late to add this definition,

	    # since it may make other tests incompatible.

	    AC_MSG_ERROR([The available timer requires _XOPEN_SOURCE=500.  Add -D_XOPEN_SOURCE=500 to CFLAGS and rerun configure])

        fi

    fi

    # 

    # FreeBSD 4.3 incorrectly puts the header into sys/time.h; 

    # time.h is required (see pages 45 and 46 in the POSIX standard).

    # See if we can compile

    AC_CACHE_CHECK([for CLOCK_REALTIME defined in time.h],pac_cv_posix_clock_realtime,[

    AC_TRY_COMPILE([

#include <time.h>],[

    clockid_t cid = CLOCK_REALTIME;],pac_cv_posix_clock_realtime=yes,

pac_cv_posix_clock_realtime=no)])

    if test "$pac_cv_posix_clock_realtime" = "no" ; then

         AC_MSG_WARN([POSIX timer requires definitions in time.h])

	 # Check for the definition in sys/time.h, which is where

	 # OpenBSD and FreeBSD have put it by mistake

         AC_TRY_COMPILE([

#include <time.h>

#include <sys/time.h>],[

    clockid_t cid = CLOCK_REALTIME;],pac_cv_posix_clock_realtime=yes,

pac_cv_posix_clock_realtime=no)

	if test "$pac_cv_posix_clock_realtime" = yes ; then

	    AC_MSG_WARN([sys/time.h required for POSIX timer])

	    AC_DEFINE(NEEDS_SYS_TIME_H,1,[Define if sys/time.h is required to get timer definitions])

	else

	    AC_MSG_ERROR([Cannot find the definition of CLOCK_REALTIME for the POSIX timer])

	fi

    fi

    ;;

    gettimeofday)

    MPL_TIMER_TYPE="struct timeval"

    # We may have already tested for gettimeofday.  If we got a "yes",

    # we're good to go

    if test "$ac_cv_func_gettimeofday" != "yes" ; then

        AC_CHECK_FUNC(gettimeofday,,[

         AC_MSG_ERROR([Requested timer gettimeofday is not available])

])

    fi

    ;;

    linux86_cycle|linux86_cycle_2)

# The following AC_TRY_RUN statements are needed because x86_64 compilers

# usually know about rdtscp but the cpu may or may not actually implement the

# feature.  This is not cross-compile safe, unfortunately.  In the long run we

# should allow the user to override this with a configure flag.

    AC_CACHE_CHECK([that linux86 cycle counter is available],

        pac_cv_linux86_cycle,

            AC_TRY_RUN([

int main()

{

    /* rdtscp */

    long long var, *var_ptr=&var;

    __asm__ __volatile__("rdtscp; shl \$32, %%rdx; or %%rdx, %%rax" : "=a" (*var_ptr) : : "ecx", "rdx");

    return 0;

}

            ],pac_cv_linux86_cycle=rdtscp,

                AC_TRY_RUN([[

int main()

{

    /* cpuid 64 */

    long long var, *var_ptr=&var;

    __asm__ __volatile__("push %%rbx ; cpuid ; rdtsc ; pop %%rbx ; shl $32, %%rdx; or %%rdx, %%rax" : "=a" (*var_ptr) : : "ecx", "rdx");

    return 0;

}

                ]],pac_cv_linux86_cycle=cpuid_rdtsc64,

                    AC_TRY_RUN([[[

int main()

{

    /* cpuid 32 */

    long long var, *var_ptr=&var;

    __asm__ __volatile__("push %%ebx ; cpuid ; rdtsc ; pop %%ebx" : "=A" (*var_ptr) : : "ecx");

    return 0;

}

                    ]]],pac_cv_linux86_cycle=cpuid_rdtsc32,

                        AC_TRY_RUN([[[[

int main()

{

    /* simple */

    long long var, *var_ptr=&var;

    __asm__ __volatile__("rdtsc" : "=A" (*var_ptr));

    return 0;

}

                        ]]]],pac_cv_linux86_cycle=rdtsc,

                        pac_cv_linux86_cycle=no)

                    )

                ),

dnl The if-cross-compiling clause from the first AC_TRY_RUN.  Hope that if the

dnl compiler knows about the instruction then it's supported by the target

dnl platform.

                AC_TRY_COMPILE(,[[

                    long long var, *var_ptr=&var;

                    __asm__ __volatile__("rdtscp; shl \$32, %%rdx; or %%rdx, %%rax" : "=a" (*var_ptr) : : "ecx", "rdx");

                ]],pac_cv_linux86_cycle=rdtscp,

                    AC_TRY_COMPILE(,[[[

                        long long var, *var_ptr=&var;

                        __asm__ __volatile__("push %%rbx ; cpuid ; rdtsc ; pop %%rbx ; shl $32, %%rdx; or %%rdx, %%rax" : "=a" (*var_ptr) : : "ecx", "rdx");

                    ]]],pac_cv_linux86_cycle=cpuid_rdtsc64,

                        AC_TRY_COMPILE(,[[[[

                            long long var, *var_ptr=&var;

                            __asm__ __volatile__("push %%ebx ; cpuid ; rdtsc ; pop %%ebx" : "=A" (*var_ptr) : : "ecx");

                        ]]]],pac_cv_linux86_cycle=cpuid_rdtsc32,

                            AC_TRY_COMPILE(,[[[[[

                                long long var, *var_ptr=&var;

                                __asm__ __volatile__("rdtsc" : "=A" (*var_ptr));

                            ]]]]],pac_cv_linux86_cycle=rdtsc,

                            pac_cv_linux86_cycle=no)

                        )

                    )

                )

            )

    )

    case "$pac_cv_linux86_cycle" in

        "rdtscp")

            AC_DEFINE(LINUX86_CYCLE_RDTSCP,1,[Define which x86 cycle counter to use])

	    ;;

        "cpuid_rdtsc64")

            AC_DEFINE(LINUX86_CYCLE_CPUID_RDTSC64,1,[Define which x86 cycle counter to use])

            ;;

        "cpuid_rdtsc32")

            AC_DEFINE(LINUX86_CYCLE_CPUID_RDTSC32,1,[Define which x86 cycle counter to use])

	    ;;

        "rdtsc")

            AC_DEFINE(LINUX86_CYCLE_RDTSC,1,[Define which x86 cycle counter to use])

	    ;;

        *)

            cpu_gcc_x86_cycle=no

	    ;;

    esac

    if test "$cpu_gcc_x86_cycle" = "no" ; then

        AC_MSG_ERROR([Linux86 cycle counter is not available on this system and or with the $CC compiler])

    fi

    MPL_TIMER_TYPE="long long"

    ;;

    gcc_ia64_cycle)

    AC_CACHE_CHECK([that IPF timer is available],

pac_cv_ia64_cycle,[

    AC_TRY_COMPILE(,[

    long var, *var_ptr=&var;

#ifdef __INTEL_COMPILER

#include "ia64regs.h"

    var=__getReg(_IA64_REG_AR_ITC);

#else

    __asm__ __volatile__("mov %0=ar.itc" : "=r" (var_ptr));

#endif

],pac_cv_gcc_ia64_cycle=yes,pac_cv_gcc_ia64_cycle=no)])

    if test "$pac_cv_gcc_ia64_cycle" != "yes" ; then

        AC_MSG_ERROR([IPF cycle counter is not available on this system and or with the $CC compiler])

     fi

     MPL_TIMER_TYPE="long"

     ;;

    mach_absolute_time)

    AC_CHECK_FUNC(mach_absolute_time,,[AC_MSG_ERROR([mach_absolute_time is not available])])

    AC_CHECK_FUNC(mach_timebase_info,,[AC_MSG_ERROR([mach_timebase_info is not available])])

    MPL_TIMER_TYPE="uint64_t"

    ;;

    device)

    # The device selected should export the datatype for the timer

    MPL_TIMER_TYPE="void *"

    ;;

    ppc64_cycle)

    AC_CACHE_CHECK([that ppc64 timebase cycle counter is available],

                pac_cv_ppc64_cycle,[

    AC_TRY_COMPILE([

    ],[

        unsigned temp;

        asm volatile ("mfspr %0,%1" : "=r" (temp)        : "i" (0x10D));

    ],pac_cv_ppc64_cycle=yes,

    pac_cv_ppc64_cycle=no)

    ])

    if test "$pac_cv_ppc64_cycle" != "yes" ; then

        AC_MSG_ERROR([The PPC64 cycle counter is not available on this system and or with the $CC compiler])

    fi

    MPL_TIMER_TYPE="uint64_t"

    ;;

    *)

    AC_MSG_ERROR([Invalid timer type $timer_type])

    ;;

esac

# Convert timer type to upper case

timer_type=`echo $timer_type | \

    tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`

MPL_TIMER_KIND=MPL_TIMER_KIND__$timer_type

AC_SUBST(MPL_TIMER_KIND)

AC_SUBST(MPL_TIMER_TYPE)

AC_MSG_NOTICE([Timer type selected is $timer_type])

#######################################################################

## END OF TIMER CODE

#######################################################################

#######################################################################

## START OF PROCESSOR YIELD CODE

#######################################################################

# If the user specified a method to use, we check if it's available.

# If a method was not specified, we make a guess based on the OS.  The

# default is to use sched_yield() or yield() if one is available,

# otherwise, default to nothing.  After that we define the appropriate

# macro.

AC_CHECK_HEADERS(sched.h)

AC_CHECK_HEADERS(unistd.h)

AC_CHECK_HEADERS(sys/select.h)

AC_CHECK_FUNCS(sched_yield yield usleep sleep select)

if test "$ac_cv_func_usleep" = "yes" ; then

    PAC_FUNC_NEEDS_DECL([#include <unistd.h>],usleep)

fi

AC_ARG_ENABLE([yield],

    [AS_HELP_STRING([--enable-yield], [choose a method to yield the processor in busy loops.  Available methods are: sched_yield, yield, select, usleep, sleep, nothing])],

    [AS_CASE([$enableval],

        [sched_yield], [AS_IF([test "x$ac_cv_func_sched_yield" != "xyes"], [enable_yield=unavail])],

        [yield],       [AS_IF([test "x$ac_cv_func_yield"       != "xyes"], [enable_yield=unavail])],

        [select],      [AS_IF([test "x$ac_cv_func_select"      != "xyes"], [enable_yield=unavail])],

        [usleep],      [AS_IF([test "x$ac_cv_func_usleep"      != "xyes"], [enable_yield=unavail])],

        [sleep],       [AS_IF([test "x$ac_cv_func_sleep"       != "xyes"], [enable_yield=unavail])],

        [nothing|no|none], [],

        [AC_MSG_ERROR([Invalid option $enableval for --enable-yield])])

     AS_IF([test "x$enable_yield" = "xunavail"],

              [AC_MSG_ERROR([Yield method $enableval is not available on this platform.])])

    ],

    [# none specified by user; make a guess based on os

     AS_CASE([$host],

        [*-*-darwin*],

            [# In Lion, sched_yield worked but none of the other options had any effect

             AS_IF([test "x$ac_cv_func_sched_yield" = "xyes"], [enable_yield=sched_yield],

                   [enable_yield=nothing])],

        [*-*-linux*],

            [# sched_yield() has been broken in linux since 2.6.23, and no good alternative exists.

             enable_yield=nothing],

        [# default: just use sched_yield() or yield()

         AS_IF([test "x$ac_cv_func_sched_yield" = "xyes"], [enable_yield=sched_yield],

               [test "x$ac_cv_func_yield" = "xyes"], [enable_yield=yield],

               [enable_yield=nothing])])

    ]

)

# set the appropriate macro

AS_CASE([$enable_yield],

    [sched_yield],

        [AC_DEFINE(USE_SCHED_YIELD_FOR_YIELD,1,[Define to use sched_yield to yield processor])],

    [yield],

        [AC_DEFINE(USE_YIELD_FOR_YIELD,1,[Define to use yield to yield processor])],

    [select],

        [AC_DEFINE(USE_SELECT_FOR_YIELD,1,[Define to use select to yield processor])],

    [usleep],

        [AC_DEFINE(USE_USLEEP_FOR_YIELD,1,[Define to use usleep to yield processor])],

    [sleep],

        [AC_DEFINE(USE_SLEEP_FOR_YIELD,1,[Define to use sleep to yield processor])],

    [nothing|no|none],

        [AC_DEFINE(USE_NOTHING_FOR_YIELD,1,[Define to use nothing to yield processor])],

    [AC_MSG_ERROR([Invalid value $enable_yield for enable_yield.])]

)

#######################################################################

## END OF PROCESSOR YIELD CODE

#######################################################################

#######################################################################

## START OF THREADS CODE

#######################################################################

PAC_SET_HEADER_LIB_PATH(uti)

AC_ARG_WITH([thread-package],

[  --with-thread-package=package     Thread package to use. Supported thread packages include:

        posix or pthreads - POSIX threads (default, if required)

        solaris - Solaris threads (Solaris OS only)

        abt or argobots - Argobots threads

        win - windows threads

        uti - POSIX threads plus Utility Thread Offloading library

        none - no threads

],,with_thread_package=posix)

if test "${thread_pkg_required}" = "no" -o "${with_thread_package}" = "no" ; then

   with_thread_package=none

fi

if test "${with_thread_package}" = "yes" ; then

   with_thread_package=posix

fi

if test "${thread_pkg_required}" = "yes" -a "${with_thread_package}" = "none" ; then

   AC_ERROR([if no thread package is available, use --enable-threads=single or funneled])

fi

THREAD_PACKAGE_NAME=MPL_THREAD_PACKAGE_INVALID

case $with_thread_package in

    posix|pthreads|uti)

	if test "${with_thread_package}" = "pthreads" ; then

	    with_thread_package=posix

	fi

	AC_CHECK_HEADERS(pthread.h)

        # If pthreads library is found, just include it on the link line. We don't try

        # to test if the C compiler needs it or not, since the C++ or Fortran

        # compilers might need it even if the C compiler doesn't

        # (nvcc with gfortran, for example).

        #

        # OSF1 has __pthread_create but not pthread_create (because of

        # inconsistencies in the pthread spec).  Thus, we look for pthread_key_create

        AC_CHECK_LIB([pthread],[pthread_key_create],have_pthreads=yes)

	if test "$have_pthreads" = "yes" ; then

	   PAC_PREPEND_FLAG([-lpthread],[LIBS])

	fi

        AC_CHECK_FUNCS(pthread_yield)

        # this check should come after the AC_CHECK_LIB for -lpthread

        AC_CHECK_FUNC([pthread_key_create],[],[AC_MSG_ERROR([unable to find pthreads library])])

	# Check for a routine that specify a routine to call on

	# thread exit.  We can use this to release memory that may

	# be allocated by the MPL library in the thread.

	# A complication: pthread_cleanup_push may be a macro; in that

	# case, check_funcs will fail to find it.

	# Under OSX, pthread_cleanup_push and pop are macros that must

	# appear together in the same lexical scope, and hence are

	# really useless in libraries that may allocate data within

	# a user-managed thread.

	AC_CHECK_FUNCS(pthread_cleanup_push)

	if test "$ac_cv_func_pthread_cleanup_push" = "no" ; then

            AC_CACHE_CHECK([whether pthread_cleanup_push is available (may be a macro in pthread.h)],pac_cv_func_pthread_cleanup_push,[

	    AC_TRY_LINK([

#include <pthread.h>

void f1(void *a) { return; }],

[pthread_cleanup_push( f1, (void *)0 );],

            pac_cv_func_pthread_cleanup_push=yes,

            pac_cv_func_pthread_cleanup_push=no)])

            if test "$pac_cv_func_pthread_cleanup_push" = yes ; then

	        AC_DEFINE(HAVE_PTHREAD_CLEANUP_PUSH_MACRO,1,[Define if pthread_cleanup_push is available, even as a macro])

            fi

        fi

	if test "${with_thread_package}" = "uti" ; then

	    PAC_CHECK_HEADER_LIB(uti.h,uti,uti_attr_init,have_uti=yes,have_uti=no)

	    if test "${have_uti}" = "yes" ; then

		AC_MSG_NOTICE([Using POSIX and Utility Thread Offloading library for thread package])

	    else

		AC_MSG_ERROR([Unable to find Utility Thread Offloading library])

	    fi

	    THREAD_PACKAGE_NAME=MPL_THREAD_PACKAGE_UTI

	else

	    AC_MSG_NOTICE([POSIX will be used for thread package.])

	    THREAD_PACKAGE_NAME=MPL_THREAD_PACKAGE_POSIX

	fi

	;;

    solaris)

	AC_CHECK_HEADERS(thread.h)

	AC_CHECK_FUNCS(thr_yield)

	AC_SEARCH_LIBS(thr_create,thread,found=yes,found=no)

	if test "$found" != "yes" ; then

	   AC_MSG_ERROR([unable to find Solaris threads library])

	fi

	# FIXME: need to add -mt if using solaris compilers

        THREAD_PACKAGE_NAME=MPL_THREAD_PACKAGE_SOLARIS

	;;

    win|windows)

        with_thread_package=win

        THREAD_PACKAGE_NAME=MPL_THREAD_PACKAGE_WIN

        AC_MSG_ERROR([The 'win' thread package is not supported via autoconf builds at this time.])

        ;;

    abt|argobots)

        with_thread_package=argobots

        AC_CHECK_HEADER([abt.h],[],AC_MSG_ERROR([unable to find Argobots header file]))

        AC_CHECK_LIB([abt],[ABT_key_create],[],AC_MSG_ERROR([unable to find Argobots library]))

        PAC_PREPEND_FLAG([-labt],[LIBS])

        THREAD_PACKAGE_NAME=MPL_THREAD_PACKAGE_ARGOBOTS

        ;;

    no|none)

	with_thread_package=none

        THREAD_PACKAGE_NAME=MPL_THREAD_PACKAGE_NONE

	;;

    *)

	AC_MSG_ERROR([The specified thread package, $with_thread_package, is not supported.])

	;;

esac

# Define and export the selected thread library so that other packages

# know what's used in MPL

AC_DEFINE_UNQUOTED([THREAD_PACKAGE_NAME],[$THREAD_PACKAGE_NAME],[set to the name of the thread package])

# check for compiler-support for thread-local storage (MPL_TLS)

if test "${with_thread_package}" != "argobots" ; then

    PAC_CC_CHECK_TLS

fi

#######################################################################

## END OF THREADS CODE

#######################################################################

#######################################################################

## START OF PROCESS MUTEX CODE

#######################################################################

AC_ARG_WITH([proc-mutex-package],

[  --with-proc-mutex-package=package     Interprocess mutex package to use. Supported packages include:

        posix or pthreads - POSIX threads (default, if required)

        none - no interprocess mutex support

],,with_proc_mutex_package=posix)

if test "${with_proc_mutex_package}" = "no" ; then

   with_proc_mutex_package=none

fi

if test "${with_proc_mutex_package}" = "yes" ; then

   with_proc_mutex_package=posix

fi

PROC_MUTEX_PACKAGE_NAME=MPL_PROC_MUTEX_PACKAGE_INVALID

case $with_proc_mutex_package in

  posix|pthreads)

    if test "${with_proc_mutex_package}" = "pthreads" ; then

        with_proc_mutex_package=posix

    fi

    # Do not prepend -lpthread again if already checked by thread package

    if test "${with_thread_package}" != "posix" ; then

        AC_CHECK_HEADERS(pthread.h)

        # If pthreads library is found, just include it on the link line. We don't try

        # to test if the C compiler needs it or not, since the C++ or Fortran

        # compilers might need it even if the C compiler doesn't

        # (nvcc with gfortran, for example).

        AC_CHECK_LIB([pthread],[pthread_mutex_init],have_pthreads=yes)

        if test "$have_pthreads" = "yes" ; then

           PAC_PREPEND_FLAG([-lpthread],[LIBS])

        fi

    fi

    # this check should come after the AC_CHECK_LIB for -lpthread

    AC_CHECK_FUNC([pthread_mutex_init],[],[AC_MSG_ERROR([unable to find pthreads library])])

    # pthread_mutexattr_setpshared is first released in Issue 5

    AC_CHECK_FUNCS(pthread_mutexattr_setpshared)

    AC_MSG_NOTICE([POSIX will be used for interprocess mutex package.])

    PROC_MUTEX_PACKAGE_NAME=MPL_PROC_MUTEX_PACKAGE_POSIX

  ;;

  no|none)

    with_proc_mutex_package=none

    PROC_MUTEX_PACKAGE_NAME=MPL_PROC_MUTEX_PACKAGE_NONE

  ;;

  *)

    AC_MSG_ERROR([The specified interprocess mutex package, $with_proc_mutex_package, is not supported.])

  ;;

esac

# Define and export the selected interprocess mutex package so that other packages

# know what's used in MPL

AC_DEFINE_UNQUOTED([PROC_MUTEX_PACKAGE_NAME],[$PROC_MUTEX_PACKAGE_NAME],[set to the name of the interprocess mutex package])

#######################################################################

## END OF PROCESS MUTEX CODE

#######################################################################

#######################################################################

## START OF PTHREAD MUTEX COMMON CHECK

#######################################################################

if test "${with_thread_package}" = "pthreads" -o "${with_proc_mutex_package}" = "pthreads"; then

  # Check for PTHREAD_MUTEX_ERRORCHECK_NP and PTHREAD_MUTEX_ERRORCHECK

  AC_CACHE_CHECK([whether pthread.h defines PTHREAD_MUTEX_ERRORCHECK_NP],

  pac_cv_has_pthread_mutex_errorcheck_np,[

  AC_TRY_COMPILE([#include <pthread.h>],

                 [int a=PTHREAD_MUTEX_ERRORCHECK_NP;],

                 pac_cv_has_pthread_mutex_errorcheck_np=yes,

                 pac_cv_has_pthread_mutex_errorcheck_np=no)])

  AC_CACHE_CHECK([whether pthread.h defines PTHREAD_MUTEX_ERRORCHECK],

  pac_cv_has_pthread_mutex_errorcheck,[

  AC_TRY_COMPILE([#include <pthread.h>],

                 [int a=PTHREAD_MUTEX_ERRORCHECK;],

                 pac_cv_has_pthread_mutex_errorcheck=yes,

                 pac_cv_has_pthread_mutex_errorcheck=no)])

  if test "$pac_cv_has_pthread_mutex_errorcheck" = yes ; then

      AC_DEFINE(PTHREAD_MUTEX_ERRORCHECK_VALUE,PTHREAD_MUTEX_ERRORCHECK,

                [Define to an expression that will result in an error checking mutex type.])

  elif test "$pac_cv_has_pthread_mutex_errorcheck_np" = yes ; then

      AC_DEFINE(PTHREAD_MUTEX_ERRORCHECK_VALUE,PTHREAD_MUTEX_ERRORCHECK_NP,

                [Define to an expression that will result in an error checking mutex type.])

  fi

  PAC_FUNC_NEEDS_DECL([#include <pthread.h>],pthread_mutexattr_settype)

fi

#######################################################################

## END OF PTHREAD MUTEX COMMON CHECK

#######################################################################

#######################################################################

## START OF DBG CODE

#######################################################################

# mkstemp() is a better replacement for mktemp()

AC_HAVE_FUNCS(mkstemp)

if test "$ac_cv_func_mkstemp" = "yes" ; then

    PAC_FUNC_NEEDS_DECL([#include <stdlib.h>],mkstemp)

fi

# fdopen() converts from an fd to a FILE*

AC_HAVE_FUNCS(fdopen)

if test "$ac_cv_func_fdopen" = "yes" ; then

    PAC_FUNC_NEEDS_DECL([#include <stdio.h>],fdopen)

fi

AC_CHECK_FUNCS(getpid)

#######################################################################

## END OF DBG CODE

#######################################################################

#######################################################################

## START OF SHM CODE

#######################################################################

dnl Check for shm

PAC_ARG_SHARED_MEMORY

case $with_shared_memory in

    sysv)

        AC_DEFINE(MPL_USE_SYSV_SHM,1,[Define if use SYSV shared memory])

        ;;

    mmap)

        AC_DEFINE(MPL_USE_MMAP_SHM,1,[Define if use MMAP shared memory])

        ;;

    nt)

        AC_DEFINE(MPL_USE_NT_SHM,1,[Define if use Windows shared memory])

        ;;

    *)