This is a very large change to rename several #define values from
OMPI_* to OPAL_*. This allows opal layer to be used more independent from the whole of ompi. NOTE: 9 "svn mv" operations immediately follow this commit. This commit was SVN r21180.
This commit is contained in:
parent
64585600fc
commit
60485ff95f
2
NEWS
2
NEWS
@ -160,7 +160,7 @@ Trunk (not on release branches yet)
|
||||
set the MCA parameter orte_forward_job_control to 1.
|
||||
- Allow the sm BTL to allocate larger amounts of shared memory if
|
||||
desired (helpful for very large multi-core boxen).
|
||||
- Fix a few places where we used PATH_MAX instead of OMPI_PATH_MAX,
|
||||
- Fix a few places where we used PATH_MAX instead of OPAL_PATH_MAX,
|
||||
leading to compile problems on some platforms. Thanks to Andrea Iob
|
||||
for the bug report.
|
||||
- Fix mca_btl_openib_warn_no_device_params_found MCA parameter; it
|
||||
|
@ -70,7 +70,7 @@ Step 3: Add the following to ompi/tools/ompi_info/ompi_info.h and
|
||||
#define OMPI_BUILD_FCFLAGS ""
|
||||
#define OMPI_BUILD_LDFLAGS " "
|
||||
#define OMPI_BUILD_LIBS " "
|
||||
#define OMPI_CC_ABSOLUTE "cl"
|
||||
#define OPAL_CC_ABSOLUTE "cl"
|
||||
#define OMPI_CXX_ABSOLUTE "cl"
|
||||
#define OMPI_F77_ABSOLUTE "none"
|
||||
#define OMPI_F90_ABSOLUTE "none"
|
||||
|
@ -66,5 +66,5 @@ AC_DEFUN([OMPI_C_WEAK_SYMBOLS],[
|
||||
[ompi_cv_c_weak_symbols="no"])])
|
||||
|
||||
AS_IF([test "$ompi_cv_c_weak_symbols" = "yes"],
|
||||
[OMPI_C_HAVE_WEAK_SYMBOLS=1], [OMPI_C_HAVE_WEAK_SYMBOLS=0])
|
||||
[OPAL_C_HAVE_WEAK_SYMBOLS=1], [OPAL_C_HAVE_WEAK_SYMBOLS=0])
|
||||
]) dnl
|
||||
|
@ -22,14 +22,14 @@ dnl Tests provided by OMPI
|
||||
dnl General tests
|
||||
dnl
|
||||
|
||||
sinclude(@M4DIR@/ompi_functions.m4)
|
||||
sinclude(@M4DIR@/opal_functions.m4)
|
||||
sinclude(@M4DIR@/ompi_get_version.m4)
|
||||
|
||||
dnl
|
||||
dnl C compiler tests
|
||||
dnl
|
||||
|
||||
sinclude(@M4DIR@/ompi_setup_cc.m4)
|
||||
sinclude(@M4DIR@/opal_setup_cc.m4)
|
||||
sinclude(@M4DIR@/ompi_check_optflags.m4)
|
||||
sinclude(@M4DIR@/ompi_check_vendor.m4)
|
||||
|
||||
|
@ -29,7 +29,7 @@ AC_DEFUN([_OMPI_ATTRIBUTE_FAIL_SEARCH],[
|
||||
for i in ignore skip ; do
|
||||
$GREP -iq $i conftest.err
|
||||
if test "$?" = "0" ; then
|
||||
ompi_cv___attribute__[$1]=0
|
||||
opal_cv___attribute__[$1]=0
|
||||
break;
|
||||
fi
|
||||
done
|
||||
@ -51,7 +51,7 @@ AC_DEFUN([_OMPI_ATTRIBUTE_FAIL_SEARCH],[
|
||||
#
|
||||
AC_DEFUN([_OMPI_CHECK_SPECIFIC_ATTRIBUTE], [
|
||||
AC_MSG_CHECKING([for __attribute__([$1])])
|
||||
AC_CACHE_VAL(ompi_cv___attribute__[$1], [
|
||||
AC_CACHE_VAL(opal_cv___attribute__[$1], [
|
||||
#
|
||||
# Try to compile using the C compiler, then C++
|
||||
#
|
||||
@ -62,20 +62,20 @@ AC_DEFUN([_OMPI_CHECK_SPECIFIC_ATTRIBUTE], [
|
||||
# attribute being ignored/skipped? Grep for IgNoRe/skip in conftest.err
|
||||
# and if found, reset the ompi_cv__attribute__var=0
|
||||
#
|
||||
ompi_cv___attribute__[$1]=1
|
||||
opal_cv___attribute__[$1]=1
|
||||
_OMPI_ATTRIBUTE_FAIL_SEARCH([$1])
|
||||
],
|
||||
[ompi_cv___attribute__[$1]=0])
|
||||
if test "$ompi_cv___attribute__[$1]" = "1" ; then
|
||||
[opal_cv___attribute__[$1]=0])
|
||||
if test "$opal_cv___attribute__[$1]" = "1" ; then
|
||||
AC_LANG_PUSH(C++)
|
||||
AC_TRY_COMPILE([
|
||||
extern "C" {
|
||||
$2
|
||||
}],[],
|
||||
[
|
||||
ompi_cv___attribute__[$1]=1
|
||||
opal_cv___attribute__[$1]=1
|
||||
_OMPI_ATTRIBUTE_FAIL_SEARCH([$1])
|
||||
],[ompi_cv___attribute__[$1]=0])
|
||||
],[opal_cv___attribute__[$1]=0])
|
||||
AC_LANG_POP(C++)
|
||||
fi
|
||||
|
||||
@ -83,7 +83,7 @@ AC_DEFUN([_OMPI_CHECK_SPECIFIC_ATTRIBUTE], [
|
||||
# If the attribute is supported by both compilers,
|
||||
# try to recompile a *cross-check*, IFF defined.
|
||||
#
|
||||
if test '(' "$ompi_cv___attribute__[$1]" = "1" -a "[$3]" != "" ')' ; then
|
||||
if test '(' "$opal_cv___attribute__[$1]" = "1" -a "[$3]" != "" ')' ; then
|
||||
ac_c_werror_flag_safe=$ac_c_werror_flag
|
||||
ac_c_werror_flag="yes"
|
||||
CFLAGS_safe=$CFLAGS
|
||||
@ -94,14 +94,14 @@ AC_DEFUN([_OMPI_CHECK_SPECIFIC_ATTRIBUTE], [
|
||||
int i=4711;
|
||||
i=usage(&i);
|
||||
],
|
||||
[ompi_cv___attribute__[$1]=0],
|
||||
[opal_cv___attribute__[$1]=0],
|
||||
[
|
||||
#
|
||||
# In case we did NOT succeed: Fine, but was this due to the
|
||||
# attribute being ignored? Grep for IgNoRe in conftest.err
|
||||
# and if found, reset the ompi_cv__attribute__var=0
|
||||
#
|
||||
ompi_cv___attribute__[$1]=1
|
||||
opal_cv___attribute__[$1]=1
|
||||
_OMPI_ATTRIBUTE_FAIL_SEARCH([$1])
|
||||
])
|
||||
|
||||
@ -110,7 +110,7 @@ AC_DEFUN([_OMPI_CHECK_SPECIFIC_ATTRIBUTE], [
|
||||
fi
|
||||
])
|
||||
|
||||
if test "$ompi_cv___attribute__[$1]" = "1" ; then
|
||||
if test "$opal_cv___attribute__[$1]" = "1" ; then
|
||||
AC_MSG_RESULT([yes])
|
||||
else
|
||||
AC_MSG_RESULT([no])
|
||||
@ -127,11 +127,11 @@ AC_DEFUN([_OMPI_CHECK_SPECIFIC_ATTRIBUTE], [
|
||||
# The compilers output is parsed in _OMPI_ATTRIBUTE_FAIL_SEARCH
|
||||
#
|
||||
# To add a new attributes __NAME__ add the
|
||||
# ompi_cv___attribute__NAME
|
||||
# opal_cv___attribute__NAME
|
||||
# add a new check with _OMPI_CHECK_SPECIFIC_ATTRIBUTE (possibly with a cross-check)
|
||||
# _OMPI_CHECK_SPECIFIC_ATTRIBUTE([name], [int foo (int arg) __attribute__ ((__name__));], [], [])
|
||||
# and define the corresponding
|
||||
# AC_DEFINE_UNQUOTED(OMPI_HAVE_ATTRIBUTE_NAME, [$ompi_cv___attribute__NAME],
|
||||
# AC_DEFINE_UNQUOTED(OPAL_HAVE_ATTRIBUTE_NAME, [$opal_cv___attribute__NAME],
|
||||
# [Whether your compiler has __attribute__ NAME or not])
|
||||
# and decide on a correct macro (in opal/include/opal_config_bottom.h):
|
||||
# # define __opal_attribute_NAME(x) __attribute__(__NAME__)
|
||||
@ -145,7 +145,7 @@ AC_DEFUN([_OMPI_CHECK_SPECIFIC_ATTRIBUTE], [
|
||||
AC_DEFUN([OMPI_CHECK_ATTRIBUTES], [
|
||||
AC_MSG_CHECKING(for __attribute__)
|
||||
|
||||
AC_CACHE_VAL(ompi_cv___attribute__, [
|
||||
AC_CACHE_VAL(opal_cv___attribute__, [
|
||||
AC_TRY_COMPILE(
|
||||
[#include <stdlib.h>
|
||||
/* Check for the longest available __attribute__ (since gcc-2.3) */
|
||||
@ -155,11 +155,11 @@ AC_DEFUN([OMPI_CHECK_ATTRIBUTES], [
|
||||
};
|
||||
],
|
||||
[],
|
||||
[ompi_cv___attribute__=1],
|
||||
[ompi_cv___attribute__=0],
|
||||
[opal_cv___attribute__=1],
|
||||
[opal_cv___attribute__=0],
|
||||
)
|
||||
|
||||
if test "$ompi_cv___attribute__" = "1" ; then
|
||||
if test "$opal_cv___attribute__" = "1" ; then
|
||||
AC_TRY_COMPILE(
|
||||
[#include <stdlib.h>
|
||||
/* Check for the longest available __attribute__ (since gcc-2.3) */
|
||||
@ -169,39 +169,39 @@ AC_DEFUN([OMPI_CHECK_ATTRIBUTES], [
|
||||
};
|
||||
],
|
||||
[],
|
||||
[ompi_cv___attribute__=1],
|
||||
[ompi_cv___attribute__=0],
|
||||
[opal_cv___attribute__=1],
|
||||
[opal_cv___attribute__=0],
|
||||
)
|
||||
fi
|
||||
])
|
||||
AC_DEFINE_UNQUOTED(OMPI_HAVE_ATTRIBUTE, [$ompi_cv___attribute__],
|
||||
AC_DEFINE_UNQUOTED(OPAL_HAVE_ATTRIBUTE, [$opal_cv___attribute__],
|
||||
[Whether your compiler has __attribute__ or not])
|
||||
|
||||
#
|
||||
# Now that we know the compiler support __attribute__ let's check which kind of
|
||||
# attributed are supported.
|
||||
#
|
||||
if test "$ompi_cv___attribute__" = "0" ; then
|
||||
if test "$opal_cv___attribute__" = "0" ; then
|
||||
AC_MSG_RESULT([no])
|
||||
ompi_cv___attribute__aligned=0
|
||||
ompi_cv___attribute__always_inline=0
|
||||
ompi_cv___attribute__cold=0
|
||||
ompi_cv___attribute__const=0
|
||||
ompi_cv___attribute__deprecated=0
|
||||
ompi_cv___attribute__format=0
|
||||
ompi_cv___attribute__hot=0
|
||||
ompi_cv___attribute__malloc=0
|
||||
ompi_cv___attribute__may_alias=0
|
||||
ompi_cv___attribute__no_instrument_function=0
|
||||
ompi_cv___attribute__nonnull=0
|
||||
ompi_cv___attribute__noreturn=0
|
||||
ompi_cv___attribute__packed=0
|
||||
ompi_cv___attribute__pure=0
|
||||
ompi_cv___attribute__sentinel=0
|
||||
ompi_cv___attribute__unused=0
|
||||
ompi_cv___attribute__visibility=0
|
||||
ompi_cv___attribute__warn_unused_result=0
|
||||
ompi_cv___attribute__weak_alias=0
|
||||
opal_cv___attribute__aligned=0
|
||||
opal_cv___attribute__always_inline=0
|
||||
opal_cv___attribute__cold=0
|
||||
opal_cv___attribute__const=0
|
||||
opal_cv___attribute__deprecated=0
|
||||
opal_cv___attribute__format=0
|
||||
opal_cv___attribute__hot=0
|
||||
opal_cv___attribute__malloc=0
|
||||
opal_cv___attribute__may_alias=0
|
||||
opal_cv___attribute__no_instrument_function=0
|
||||
opal_cv___attribute__nonnull=0
|
||||
opal_cv___attribute__noreturn=0
|
||||
opal_cv___attribute__packed=0
|
||||
opal_cv___attribute__pure=0
|
||||
opal_cv___attribute__sentinel=0
|
||||
opal_cv___attribute__unused=0
|
||||
opal_cv___attribute__visibility=0
|
||||
opal_cv___attribute__warn_unused_result=0
|
||||
opal_cv___attribute__weak_alias=0
|
||||
else
|
||||
AC_MSG_RESULT([yes])
|
||||
|
||||
@ -476,42 +476,42 @@ AC_DEFUN([OMPI_CHECK_ATTRIBUTES], [
|
||||
|
||||
# Now that all the values are set, define them
|
||||
|
||||
AC_DEFINE_UNQUOTED(OMPI_HAVE_ATTRIBUTE_ALIGNED, [$ompi_cv___attribute__aligned],
|
||||
AC_DEFINE_UNQUOTED(OPAL_HAVE_ATTRIBUTE_ALIGNED, [$opal_cv___attribute__aligned],
|
||||
[Whether your compiler has __attribute__ aligned or not])
|
||||
AC_DEFINE_UNQUOTED(OMPI_HAVE_ATTRIBUTE_ALWAYS_INLINE, [$ompi_cv___attribute__always_inline],
|
||||
AC_DEFINE_UNQUOTED(OPAL_HAVE_ATTRIBUTE_ALWAYS_INLINE, [$opal_cv___attribute__always_inline],
|
||||
[Whether your compiler has __attribute__ always_inline or not])
|
||||
AC_DEFINE_UNQUOTED(OMPI_HAVE_ATTRIBUTE_COLD, [$ompi_cv___attribute__cold],
|
||||
AC_DEFINE_UNQUOTED(OPAL_HAVE_ATTRIBUTE_COLD, [$opal_cv___attribute__cold],
|
||||
[Whether your compiler has __attribute__ cold or not])
|
||||
AC_DEFINE_UNQUOTED(OMPI_HAVE_ATTRIBUTE_CONST, [$ompi_cv___attribute__const],
|
||||
AC_DEFINE_UNQUOTED(OPAL_HAVE_ATTRIBUTE_CONST, [$opal_cv___attribute__const],
|
||||
[Whether your compiler has __attribute__ const or not])
|
||||
AC_DEFINE_UNQUOTED(OMPI_HAVE_ATTRIBUTE_DEPRECATED, [$ompi_cv___attribute__deprecated],
|
||||
AC_DEFINE_UNQUOTED(OPAL_HAVE_ATTRIBUTE_DEPRECATED, [$opal_cv___attribute__deprecated],
|
||||
[Whether your compiler has __attribute__ deprecated or not])
|
||||
AC_DEFINE_UNQUOTED(OMPI_HAVE_ATTRIBUTE_FORMAT, [$ompi_cv___attribute__format],
|
||||
AC_DEFINE_UNQUOTED(OPAL_HAVE_ATTRIBUTE_FORMAT, [$opal_cv___attribute__format],
|
||||
[Whether your compiler has __attribute__ format or not])
|
||||
AC_DEFINE_UNQUOTED(OMPI_HAVE_ATTRIBUTE_HOT, [$ompi_cv___attribute__hot],
|
||||
AC_DEFINE_UNQUOTED(OPAL_HAVE_ATTRIBUTE_HOT, [$opal_cv___attribute__hot],
|
||||
[Whether your compiler has __attribute__ hot or not])
|
||||
AC_DEFINE_UNQUOTED(OMPI_HAVE_ATTRIBUTE_MALLOC, [$ompi_cv___attribute__malloc],
|
||||
AC_DEFINE_UNQUOTED(OPAL_HAVE_ATTRIBUTE_MALLOC, [$opal_cv___attribute__malloc],
|
||||
[Whether your compiler has __attribute__ malloc or not])
|
||||
AC_DEFINE_UNQUOTED(OMPI_HAVE_ATTRIBUTE_MAY_ALIAS, [$ompi_cv___attribute__may_alias],
|
||||
AC_DEFINE_UNQUOTED(OPAL_HAVE_ATTRIBUTE_MAY_ALIAS, [$opal_cv___attribute__may_alias],
|
||||
[Whether your compiler has __attribute__ may_alias or not])
|
||||
AC_DEFINE_UNQUOTED(OMPI_HAVE_ATTRIBUTE_NO_INSTRUMENT_FUNCTION, [$ompi_cv___attribute__no_instrument_function],
|
||||
AC_DEFINE_UNQUOTED(OPAL_HAVE_ATTRIBUTE_NO_INSTRUMENT_FUNCTION, [$opal_cv___attribute__no_instrument_function],
|
||||
[Whether your compiler has __attribute__ no_instrument_function or not])
|
||||
AC_DEFINE_UNQUOTED(OMPI_HAVE_ATTRIBUTE_NONNULL, [$ompi_cv___attribute__nonnull],
|
||||
AC_DEFINE_UNQUOTED(OPAL_HAVE_ATTRIBUTE_NONNULL, [$opal_cv___attribute__nonnull],
|
||||
[Whether your compiler has __attribute__ nonnull or not])
|
||||
AC_DEFINE_UNQUOTED(OMPI_HAVE_ATTRIBUTE_NORETURN, [$ompi_cv___attribute__noreturn],
|
||||
AC_DEFINE_UNQUOTED(OPAL_HAVE_ATTRIBUTE_NORETURN, [$opal_cv___attribute__noreturn],
|
||||
[Whether your compiler has __attribute__ noreturn or not])
|
||||
AC_DEFINE_UNQUOTED(OMPI_HAVE_ATTRIBUTE_PACKED, [$ompi_cv___attribute__packed],
|
||||
AC_DEFINE_UNQUOTED(OPAL_HAVE_ATTRIBUTE_PACKED, [$opal_cv___attribute__packed],
|
||||
[Whether your compiler has __attribute__ packed or not])
|
||||
AC_DEFINE_UNQUOTED(OMPI_HAVE_ATTRIBUTE_PURE, [$ompi_cv___attribute__pure],
|
||||
AC_DEFINE_UNQUOTED(OPAL_HAVE_ATTRIBUTE_PURE, [$opal_cv___attribute__pure],
|
||||
[Whether your compiler has __attribute__ pure or not])
|
||||
AC_DEFINE_UNQUOTED(OMPI_HAVE_ATTRIBUTE_SENTINEL, [$ompi_cv___attribute__sentinel],
|
||||
AC_DEFINE_UNQUOTED(OPAL_HAVE_ATTRIBUTE_SENTINEL, [$opal_cv___attribute__sentinel],
|
||||
[Whether your compiler has __attribute__ sentinel or not])
|
||||
AC_DEFINE_UNQUOTED(OMPI_HAVE_ATTRIBUTE_UNUSED, [$ompi_cv___attribute__unused],
|
||||
AC_DEFINE_UNQUOTED(OPAL_HAVE_ATTRIBUTE_UNUSED, [$opal_cv___attribute__unused],
|
||||
[Whether your compiler has __attribute__ unused or not])
|
||||
AC_DEFINE_UNQUOTED(OMPI_HAVE_ATTRIBUTE_VISIBILITY, [$ompi_cv___attribute__visibility],
|
||||
AC_DEFINE_UNQUOTED(OPAL_HAVE_ATTRIBUTE_VISIBILITY, [$opal_cv___attribute__visibility],
|
||||
[Whether your compiler has __attribute__ visibility or not])
|
||||
AC_DEFINE_UNQUOTED(OMPI_HAVE_ATTRIBUTE_WARN_UNUSED_RESULT, [$ompi_cv___attribute__warn_unused_result],
|
||||
AC_DEFINE_UNQUOTED(OPAL_HAVE_ATTRIBUTE_WARN_UNUSED_RESULT, [$opal_cv___attribute__warn_unused_result],
|
||||
[Whether your compiler has __attribute__ warn unused result or not])
|
||||
AC_DEFINE_UNQUOTED(OMPI_HAVE_ATTRIBUTE_WEAK_ALIAS, [$ompi_cv___attribute__weak_alias],
|
||||
AC_DEFINE_UNQUOTED(OPAL_HAVE_ATTRIBUTE_WEAK_ALIAS, [$opal_cv___attribute__weak_alias],
|
||||
[Whether your compiler has __attribute__ weak alias or not])
|
||||
])
|
||||
|
@ -48,6 +48,6 @@ AC_DEFUN([OMPI_CHECK_BROKEN_QSORT],[
|
||||
define_result=0
|
||||
fi
|
||||
AC_MSG_RESULT([$result])
|
||||
AC_DEFINE_UNQUOTED([OMPI_HAVE_BROKEN_QSORT], [$define_result],
|
||||
AC_DEFINE_UNQUOTED([OPAL_HAVE_BROKEN_QSORT], [$define_result],
|
||||
[whether qsort is broken or not])
|
||||
])
|
||||
|
@ -8,9 +8,9 @@ dnl
|
||||
dnl $HEADER$
|
||||
dnl
|
||||
dnl defines:
|
||||
dnl OMPI_$1_USE_PRAGMA_IDENT
|
||||
dnl OMPI_$1_USE_IDENT
|
||||
dnl OMPI_$1_USE_CONST_CHAR_IDENT
|
||||
dnl OPAL_$1_USE_PRAGMA_IDENT
|
||||
dnl OPAL_$1_USE_IDENT
|
||||
dnl OPAL_$1_USE_CONST_CHAR_IDENT
|
||||
dnl
|
||||
|
||||
# OMPI_CHECK_IDENT(compiler-env, compiler-flags,
|
||||
@ -21,39 +21,39 @@ dnl
|
||||
AC_DEFUN([OMPI_CHECK_IDENT], [
|
||||
AC_MSG_CHECKING([for $4 ident string support])
|
||||
|
||||
ompi_pragma_ident_happy=0
|
||||
ompi_ident_happy=0
|
||||
ompi_static_const_char_happy=0
|
||||
opal_pragma_ident_happy=0
|
||||
opal_ident_happy=0
|
||||
opal_static_const_char_happy=0
|
||||
_OMPI_CHECK_IDENT(
|
||||
[$1], [$2], [$3],
|
||||
[[#]pragma ident], [],
|
||||
[ompi_pragma_ident_happy=1
|
||||
[opal_pragma_ident_happy=1
|
||||
ompi_message="[#]pragma ident"],
|
||||
_OMPI_CHECK_IDENT(
|
||||
[$1], [$2], [$3],
|
||||
[[#]ident], [],
|
||||
[ompi_ident_happy=1
|
||||
[opal_ident_happy=1
|
||||
ompi_message="[#]ident"],
|
||||
_OMPI_CHECK_IDENT(
|
||||
[$1], [$2], [$3],
|
||||
[[#]pragma comment(exestr, ], [)],
|
||||
[ompi_pragma_comment_happy=1
|
||||
[opal_pragma_comment_happy=1
|
||||
ompi_message="[#]pragma comment"],
|
||||
[ompi_static_const_char_happy=1
|
||||
[opal_static_const_char_happy=1
|
||||
ompi_message="static const char[[]]"])))
|
||||
|
||||
AC_DEFINE_UNQUOTED([OMPI_$1_USE_PRAGMA_IDENT],
|
||||
[$ompi_pragma_ident_happy], [Use #pragma ident strings for $4 files])
|
||||
AC_DEFINE_UNQUOTED([OMPI_$1_USE_IDENT],
|
||||
[$ompi_ident_happy], [Use #ident strings for $4 files])
|
||||
AC_DEFINE_UNQUOTED([OMPI_$1_USE_PRAGMA_COMMENT],
|
||||
[$ompi_pragma_comment_happy], [Use #pragma comment for $4 files])
|
||||
AC_DEFINE_UNQUOTED([OMPI_$1_USE_CONST_CHAR_IDENT],
|
||||
[$ompi_static_const_char_happy], [Use static const char[] strings for $4 files])
|
||||
AC_DEFINE_UNQUOTED([OPAL_$1_USE_PRAGMA_IDENT],
|
||||
[$opal_pragma_ident_happy], [Use #pragma ident strings for $4 files])
|
||||
AC_DEFINE_UNQUOTED([OPAL_$1_USE_IDENT],
|
||||
[$opal_ident_happy], [Use #ident strings for $4 files])
|
||||
AC_DEFINE_UNQUOTED([OPAL_$1_USE_PRAGMA_COMMENT],
|
||||
[$opal_pragma_comment_happy], [Use #pragma comment for $4 files])
|
||||
AC_DEFINE_UNQUOTED([OPAL_$1_USE_CONST_CHAR_IDENT],
|
||||
[$opal_static_const_char_happy], [Use static const char[] strings for $4 files])
|
||||
|
||||
AC_MSG_RESULT([$ompi_message])
|
||||
|
||||
unset ompi_pragma_ident_happy ompi_ident_happy ompi_static_const_char_happy ompi_message
|
||||
unset opal_pragma_ident_happy opal_ident_happy opal_static_const_char_happy ompi_message
|
||||
])
|
||||
|
||||
# _OMPI_CHECK_IDENT(compiler-env, compiler-flags,
|
||||
|
@ -24,7 +24,7 @@ AC_DEFUN([OMPI_CHECK_PTHREAD_PIDS],[
|
||||
# Dependencies: None
|
||||
#
|
||||
# Sets:
|
||||
# OMPI_THREADS_HAVE_DIFFERENT_PIDS (variable)
|
||||
# OPAL_THREADS_HAVE_DIFFERENT_PIDS (variable)
|
||||
#
|
||||
# Test for Linux-like threads in the system. We will need to handle things like
|
||||
# getpid() differently in the case of a Linux-like threads model.
|
||||
@ -61,16 +61,16 @@ void *checkpid(void *arg) {
|
||||
ret = 1;
|
||||
pthread_exit((void *) &ret);
|
||||
}],
|
||||
[MSG=no OMPI_THREADS_HAVE_DIFFERENT_PIDS=0],
|
||||
[MSG=yes OMPI_THREADS_HAVE_DIFFERENT_PIDS=1],
|
||||
[MSG=no OPAL_THREADS_HAVE_DIFFERENT_PIDS=0],
|
||||
[MSG=yes OPAL_THREADS_HAVE_DIFFERENT_PIDS=1],
|
||||
[case $host in
|
||||
*-linux*)
|
||||
MSG="cross compiling - assuming yes"
|
||||
OMPI_THREADS_HAVE_DIFFERENT_PIDS=1
|
||||
OPAL_THREADS_HAVE_DIFFERENT_PIDS=1
|
||||
;;
|
||||
*)
|
||||
MSG="cross compiling - assuming no"
|
||||
OMPI_THREADS_HAVE_DIFFERENT_PIDS=0
|
||||
OPAL_THREADS_HAVE_DIFFERENT_PIDS=0
|
||||
;;
|
||||
esac
|
||||
])
|
||||
@ -81,7 +81,7 @@ LDFLAGS="$LDFLAGS_save"
|
||||
LIBS="$LIBS_save"
|
||||
|
||||
AC_MSG_RESULT([$MSG])
|
||||
AC_DEFINE_UNQUOTED(OMPI_THREADS_HAVE_DIFFERENT_PIDS, $OMPI_THREADS_HAVE_DIFFERENT_PIDS)
|
||||
AC_DEFINE_UNQUOTED(OPAL_THREADS_HAVE_DIFFERENT_PIDS, $OPAL_THREADS_HAVE_DIFFERENT_PIDS)
|
||||
|
||||
#
|
||||
# if pthreads is not available, then the system does not have an insane threads
|
||||
|
@ -29,7 +29,7 @@ AC_DEFUN([OMPI_CHECK_VISIBILITY],[
|
||||
AC_ARG_ENABLE(visibility,
|
||||
AC_HELP_STRING([--enable-visibility],
|
||||
[enable visibility feature of certain compilers/linkers (default: enabled)]))
|
||||
if test "$enable_visibility" = "no" -o "$ompi_cv___attribute__visibility" = "0"; then
|
||||
if test "$enable_visibility" = "no" -o "$opal_cv___attribute__visibility" = "0"; then
|
||||
AC_MSG_CHECKING([enable symbol visibility])
|
||||
AC_MSG_RESULT([no])
|
||||
have_visibility=0
|
||||
@ -103,7 +103,7 @@ AC_DEFUN([OMPI_CHECK_VISIBILITY],[
|
||||
CFLAGS="$CFLAGS_orig$add"
|
||||
unset add
|
||||
fi
|
||||
AC_DEFINE_UNQUOTED([OMPI_C_HAVE_VISIBILITY], [$have_visibility],
|
||||
AC_DEFINE_UNQUOTED([OPAL_C_HAVE_VISIBILITY], [$have_visibility],
|
||||
[Whether C compiler supports -fvisibility])
|
||||
|
||||
])
|
||||
|
@ -27,26 +27,26 @@ dnl
|
||||
dnl #################################################################
|
||||
AC_DEFUN([OMPI_CHECK_ASM_TEXT],[
|
||||
AC_MSG_CHECKING([directive for setting text section])
|
||||
ompi_cv_asm_text=""
|
||||
opal_cv_asm_text=""
|
||||
if test "$ompi_cv_c_compiler_vendor" = "microsoft" ; then
|
||||
# text section will be brought in with the rest of
|
||||
# header for MS - leave blank for now
|
||||
ompi_cv_asm_text=""
|
||||
opal_cv_asm_text=""
|
||||
else
|
||||
case $host in
|
||||
*-aix*)
|
||||
ompi_cv_asm_text=[".csect .text[PR]"]
|
||||
opal_cv_asm_text=[".csect .text[PR]"]
|
||||
;;
|
||||
*)
|
||||
ompi_cv_asm_text=".text"
|
||||
opal_cv_asm_text=".text"
|
||||
;;
|
||||
esac
|
||||
fi
|
||||
AC_MSG_RESULT([$ompi_cv_asm_text])
|
||||
AC_DEFINE_UNQUOTED([OMPI_ASM_TEXT], ["$ompi_cv_asm_text"],
|
||||
AC_MSG_RESULT([$opal_cv_asm_text])
|
||||
AC_DEFINE_UNQUOTED([OPAL_ASM_TEXT], ["$opal_cv_asm_text"],
|
||||
[Assembly directive for setting text section])
|
||||
OMPI_ASM_TEXT="$ompi_cv_asm_text"
|
||||
AC_SUBST(OMPI_ASM_TEXT)
|
||||
OPAL_ASM_TEXT="$opal_cv_asm_text"
|
||||
AC_SUBST(OPAL_ASM_TEXT)
|
||||
])dnl
|
||||
|
||||
|
||||
@ -54,7 +54,7 @@ dnl #################################################################
|
||||
dnl
|
||||
dnl OMPI_CHECK_ASM_GLOBAL
|
||||
dnl
|
||||
dnl Sets OMPI_ASM_GLOBAL to the value to prefix global values
|
||||
dnl Sets OPAL_ASM_GLOBAL to the value to prefix global values
|
||||
dnl
|
||||
dnl I'm sure if I don't have a test for this, there will be some
|
||||
dnl dumb platform that uses something else
|
||||
@ -62,20 +62,20 @@ dnl
|
||||
dnl #################################################################
|
||||
AC_DEFUN([OMPI_CHECK_ASM_GLOBAL],[
|
||||
AC_MSG_CHECKING([directive for exporting symbols])
|
||||
ompi_cv_asm_global=""
|
||||
opal_cv_asm_global=""
|
||||
if test "$ompi_cv_c_compiler_vendor" = "microsoft" ; then
|
||||
ompi_cv_asm_global="PUBLIC"
|
||||
opal_cv_asm_global="PUBLIC"
|
||||
else
|
||||
case $host in
|
||||
*)
|
||||
ompi_cv_asm_global=".globl"
|
||||
opal_cv_asm_global=".globl"
|
||||
;;
|
||||
esac
|
||||
fi
|
||||
AC_MSG_RESULT([$ompi_cv_asm_global])
|
||||
AC_DEFINE_UNQUOTED([OMPI_ASM_GLOBAL], ["$ompi_cv_asm_global"],
|
||||
AC_MSG_RESULT([$opal_cv_asm_global])
|
||||
AC_DEFINE_UNQUOTED([OPAL_ASM_GLOBAL], ["$opal_cv_asm_global"],
|
||||
[Assembly directive for exporting symbols])
|
||||
OMPI_ASM_GLOBAL="$ompi_cv_asm_global"
|
||||
OPAL_ASM_GLOBAL="$opal_cv_asm_global"
|
||||
AC_SUBST(OMPI_AS_GLOBAL)
|
||||
])dnl
|
||||
|
||||
@ -84,7 +84,7 @@ dnl #################################################################
|
||||
dnl
|
||||
dnl OMPI_CHECK_ASM_LSYM
|
||||
dnl
|
||||
dnl Sets OMPI_ASM_LSYM to the prefix value on a symbol to make it
|
||||
dnl Sets OPAL_ASM_LSYM to the prefix value on a symbol to make it
|
||||
dnl an internal label (jump target and whatnot)
|
||||
dnl
|
||||
dnl We look for L .L $ L$ (in that order) for something that both
|
||||
@ -103,8 +103,8 @@ AC_DEFUN([_OMPI_CHECK_ASM_LSYM],[
|
||||
for sym in L .L $ L$ ; do
|
||||
asm_result=0
|
||||
echo "configure: trying $sym" >&AC_FD_CC
|
||||
OMPI_TRY_ASSEMBLE([foobar$ompi_cv_asm_label_suffix
|
||||
${sym}mytestlabel$ompi_cv_asm_label_suffix],
|
||||
OMPI_TRY_ASSEMBLE([foobar$opal_cv_asm_label_suffix
|
||||
${sym}mytestlabel$opal_cv_asm_label_suffix],
|
||||
[# ok, we succeeded at assembling. see if we can nm,
|
||||
# throwing the results in a file
|
||||
if $NM conftest.$OBJEXT > conftest.out 2>&AC_FD_CC ; then
|
||||
@ -138,12 +138,12 @@ AC_DEFUN([OMPI_CHECK_ASM_LSYM],[
|
||||
AC_REQUIRE([AC_PROG_NM])
|
||||
|
||||
AC_CACHE_CHECK([prefix for lsym labels],
|
||||
[ompi_cv_asm_lsym],
|
||||
[_OMPI_CHECK_ASM_LSYM([ompi_cv_asm_lsym])])
|
||||
AC_DEFINE_UNQUOTED([OMPI_ASM_LSYM], ["$ompi_cv_asm_lsym"],
|
||||
[opal_cv_asm_lsym],
|
||||
[_OMPI_CHECK_ASM_LSYM([opal_cv_asm_lsym])])
|
||||
AC_DEFINE_UNQUOTED([OPAL_ASM_LSYM], ["$opal_cv_asm_lsym"],
|
||||
[Assembly prefix for lsym labels])
|
||||
OMPI_ASM_LSYM="$ompi_cv_asm_lsym"
|
||||
AC_SUBST(OMPI_ASM_LSYM)
|
||||
OPAL_ASM_LSYM="$opal_cv_asm_lsym"
|
||||
AC_SUBST(OPAL_ASM_LSYM)
|
||||
])dnl
|
||||
|
||||
dnl #################################################################
|
||||
@ -179,28 +179,28 @@ dnl #################################################################
|
||||
dnl
|
||||
dnl OMPI_CHECK_ASM_GSYM
|
||||
dnl
|
||||
dnl Sets OMPI_ASM_GSYM to the prefix value on a symbol to make it
|
||||
dnl Sets OPAL_ASM_GSYM to the prefix value on a symbol to make it
|
||||
dnl a global linkable from C. Basically, an _ or not.
|
||||
dnl
|
||||
dnl #################################################################
|
||||
AC_DEFUN([OMPI_CHECK_ASM_GSYM],[
|
||||
AC_CACHE_CHECK([prefix for global symbol labels],
|
||||
[ompi_cv_asm_gsym],
|
||||
[opal_cv_asm_gsym],
|
||||
[_OMPI_CHECK_ASM_GSYM])
|
||||
|
||||
if test "$ompi_cv_asm_gsym" = "none" ; then
|
||||
if test "$opal_cv_asm_gsym" = "none" ; then
|
||||
AC_MSG_ERROR([Could not determine global symbol label prefix])
|
||||
fi
|
||||
|
||||
AC_DEFINE_UNQUOTED([OMPI_ASM_GSYM], ["$ompi_cv_asm_gsym"],
|
||||
AC_DEFINE_UNQUOTED([OPAL_ASM_GSYM], ["$opal_cv_asm_gsym"],
|
||||
[Assembly prefix for gsym labels])
|
||||
OMPI_ASM_GSYM="$ompi_cv_asm_gsym"
|
||||
AC_SUBST(OMPI_ASM_GSYM)
|
||||
OPAL_ASM_GSYM="$opal_cv_asm_gsym"
|
||||
AC_SUBST(OPAL_ASM_GSYM)
|
||||
|
||||
])
|
||||
|
||||
AC_DEFUN([_OMPI_CHECK_ASM_GSYM],[
|
||||
ompi_cv_asm_gsym="none"
|
||||
opal_cv_asm_gsym="none"
|
||||
|
||||
for sym in "_" "" "." ; do
|
||||
asm_result=0
|
||||
@ -221,10 +221,10 @@ main()
|
||||
}
|
||||
EOF
|
||||
OMPI_TRY_ASSEMBLE([
|
||||
$ompi_cv_asm_text
|
||||
$opal_cv_asm_text
|
||||
$ompi_cv_asm_proc ${sym}gsym_test_func
|
||||
$ompi_cv_asm_global ${sym}gsym_test_func
|
||||
${sym}gsym_test_func${ompi_cv_asm_label_suffix}
|
||||
$opal_cv_asm_global ${sym}gsym_test_func
|
||||
${sym}gsym_test_func${opal_cv_asm_label_suffix}
|
||||
$ompi_cv_asm_endproc ${sym}gsym_test_func
|
||||
],
|
||||
[ompi_compile="$CC $CFLAGS -I. conftest_c.c -c > conftest.cmpl 2>&1"
|
||||
@ -253,7 +253,7 @@ $ompi_cv_asm_endproc ${sym}gsym_test_func
|
||||
fi],
|
||||
[asm_result=0])
|
||||
if test "$asm_result" = "1" ; then
|
||||
ompi_cv_asm_gsym="$sym"
|
||||
opal_cv_asm_gsym="$sym"
|
||||
break
|
||||
fi
|
||||
done
|
||||
@ -265,7 +265,7 @@ dnl #################################################################
|
||||
dnl
|
||||
dnl OMPI_CHECK_ASM_LABEL_SUFFIX
|
||||
dnl
|
||||
dnl Sets OMPI_ASM_LABEL_SUFFIX to the value to suffix for labels
|
||||
dnl Sets OPAL_ASM_LABEL_SUFFIX to the value to suffix for labels
|
||||
dnl
|
||||
dnl I'm sure if I don't have a test for this, there will be some
|
||||
dnl dumb platform that uses something else
|
||||
@ -273,16 +273,16 @@ dnl
|
||||
dnl #################################################################
|
||||
AC_DEFUN([OMPI_CHECK_ASM_LABEL_SUFFIX],[
|
||||
AC_MSG_CHECKING([suffix for labels])
|
||||
ompi_cv_asm_label_suffix=""
|
||||
opal_cv_asm_label_suffix=""
|
||||
case $host in
|
||||
*)
|
||||
ompi_cv_asm_label_suffix=":"
|
||||
opal_cv_asm_label_suffix=":"
|
||||
;;
|
||||
esac
|
||||
AC_MSG_RESULT([$ompi_cv_asm_label_suffix])
|
||||
AC_DEFINE_UNQUOTED([OMPI_ASM_LABEL_SUFFIX], ["$ompi_cv_asm_label_suffix"],
|
||||
AC_MSG_RESULT([$opal_cv_asm_label_suffix])
|
||||
AC_DEFINE_UNQUOTED([OPAL_ASM_LABEL_SUFFIX], ["$opal_cv_asm_label_suffix"],
|
||||
[Assembly suffix for labels])
|
||||
OMPI_ASM_LABEL_SUFFIX="$ompi_cv_asm_label_suffix"
|
||||
OPAL_ASM_LABEL_SUFFIX="$opal_cv_asm_label_suffix"
|
||||
AC_SUBST(OMPI_AS_LABEL_SUFFIX)
|
||||
])dnl
|
||||
|
||||
@ -291,7 +291,7 @@ dnl #################################################################
|
||||
dnl
|
||||
dnl OMPI_CHECK_ASM_ALIGN_LOG
|
||||
dnl
|
||||
dnl Sets OMPI_ASM_ALIGN_LOG to 1 if align is specified
|
||||
dnl Sets OPAL_ASM_ALIGN_LOG to 1 if align is specified
|
||||
dnl logarithmically, 0 otherwise
|
||||
dnl
|
||||
dnl #################################################################
|
||||
@ -301,12 +301,12 @@ AC_DEFUN([OMPI_CHECK_ASM_ALIGN_LOG],[
|
||||
|
||||
AC_CACHE_CHECK([if .align directive takes logarithmic value],
|
||||
[ompi_cv_asm_align_log],
|
||||
[ OMPI_TRY_ASSEMBLE([ $ompi_cv_asm_text
|
||||
[ OMPI_TRY_ASSEMBLE([ $opal_cv_asm_text
|
||||
.align 4
|
||||
$ompi_cv_asm_global foo
|
||||
$opal_cv_asm_global foo
|
||||
.byte 1
|
||||
.align 4
|
||||
foo$ompi_cv_asm_label_suffix
|
||||
foo$opal_cv_asm_label_suffix
|
||||
.byte 2],
|
||||
[ompi_asm_addr=[`$NM conftest.$OBJEXT | $GREP foo | sed -e 's/.*\([0-9a-fA-F][0-9a-fA-F]\).*foo.*/\1/'`]],
|
||||
[ompi_asm_addr=""])
|
||||
@ -324,7 +324,7 @@ foo$ompi_cv_asm_label_suffix
|
||||
ompi_asm_align_log_result=0
|
||||
fi
|
||||
|
||||
AC_DEFINE_UNQUOTED([OMPI_ASM_ALIGN_LOG],
|
||||
AC_DEFINE_UNQUOTED([OPAL_ASM_ALIGN_LOG],
|
||||
[$asm_align_log_result],
|
||||
[Assembly align directive expects logarithmic value])
|
||||
|
||||
@ -336,9 +336,9 @@ dnl #################################################################
|
||||
dnl
|
||||
dnl OMPI_CHECK_ASM_TYPE
|
||||
dnl
|
||||
dnl Sets OMPI_ASM_TYPE to the prefix for the function type to
|
||||
dnl Sets OPAL_ASM_TYPE to the prefix for the function type to
|
||||
dnl set a symbol's type as function (needed on ELF for shared
|
||||
dnl libaries). If no .type directive is needed, sets OMPI_ASM_TYPE
|
||||
dnl libaries). If no .type directive is needed, sets OPAL_ASM_TYPE
|
||||
dnl to an empty string
|
||||
dnl
|
||||
dnl We look for @ \# %
|
||||
@ -346,24 +346,24 @@ dnl
|
||||
dnl #################################################################
|
||||
AC_DEFUN([OMPI_CHECK_ASM_TYPE],[
|
||||
AC_CACHE_CHECK([prefix for function in .type],
|
||||
[ompi_cv_asm_type],
|
||||
[opal_cv_asm_type],
|
||||
[_OMPI_CHECK_ASM_TYPE])
|
||||
|
||||
AC_DEFINE_UNQUOTED([OMPI_ASM_TYPE], ["$ompi_cv_asm_type"],
|
||||
AC_DEFINE_UNQUOTED([OPAL_ASM_TYPE], ["$opal_cv_asm_type"],
|
||||
[How to set function type in .type directive])
|
||||
OMPI_ASM_TYPE="$ompi_cv_asm_type"
|
||||
AC_SUBST(OMPI_ASM_TYPE)
|
||||
OPAL_ASM_TYPE="$opal_cv_asm_type"
|
||||
AC_SUBST(OPAL_ASM_TYPE)
|
||||
])
|
||||
|
||||
AC_DEFUN([_OMPI_CHECK_ASM_TYPE],[
|
||||
ompi_cv_asm_type=""
|
||||
opal_cv_asm_type=""
|
||||
|
||||
case "${host}" in
|
||||
*-sun-solaris*)
|
||||
# GCC on solaris seems to accept just about anything, not
|
||||
# that what it defines actually works... So just hardwire
|
||||
# to the right answer
|
||||
ompi_cv_asm_type="#"
|
||||
opal_cv_asm_type="#"
|
||||
;;
|
||||
*)
|
||||
for type in @ \# % ; do
|
||||
@ -371,7 +371,7 @@ AC_DEFUN([_OMPI_CHECK_ASM_TYPE],[
|
||||
echo "configure: trying $type" >&AC_FD_CC
|
||||
OMPI_TRY_ASSEMBLE([ .type mysym, ${type}function
|
||||
mysym:],
|
||||
[ompi_cv_asm_type="${type}"
|
||||
[opal_cv_asm_type="${type}"
|
||||
asm_result=1])
|
||||
if test "$asm_result" = "1" ; then
|
||||
break
|
||||
@ -389,7 +389,7 @@ dnl #################################################################
|
||||
dnl
|
||||
dnl OMPI_CHECK_ASM_SIZE
|
||||
dnl
|
||||
dnl Sets OMPI_ASM_SIZE to 1 if we should set .size directives for
|
||||
dnl Sets OPAL_ASM_SIZE to 1 if we should set .size directives for
|
||||
dnl each function, 0 otherwise.
|
||||
dnl
|
||||
dnl #################################################################
|
||||
@ -402,15 +402,15 @@ AC_DEFUN([OMPI_CHECK_ASM_SIZE],[
|
||||
rm -f conftest.out])
|
||||
|
||||
if test "$ompi_cv_asm_need_size" = "yes" ; then
|
||||
ompi_asm_size=1
|
||||
opal_asm_size=1
|
||||
else
|
||||
ompi_asm_size=0
|
||||
opal_asm_size=0
|
||||
fi
|
||||
|
||||
AC_DEFINE_UNQUOTED([OMPI_ASM_SIZE], ["$ompi_asm_size"],
|
||||
AC_DEFINE_UNQUOTED([OPAL_ASM_SIZE], ["$opal_asm_size"],
|
||||
[Do we need to give a .size directive])
|
||||
OMPI_ASM_SIZE="$ompi_asm_size"
|
||||
AC_SUBST(OMPI_ASM_TYPE)
|
||||
OPAL_ASM_SIZE="$opal_asm_size"
|
||||
AC_SUBST(OPAL_ASM_TYPE)
|
||||
unset asm_result
|
||||
])dnl
|
||||
|
||||
@ -458,21 +458,21 @@ dnl
|
||||
dnl #################################################################
|
||||
AC_DEFUN([OMPI_CHECK_POWERPC_REG],[
|
||||
AC_MSG_CHECKING([if PowerPC registers have r prefix])
|
||||
OMPI_TRY_ASSEMBLE([$ompi_cv_asm_text
|
||||
OMPI_TRY_ASSEMBLE([$opal_cv_asm_text
|
||||
addi 1,1,0],
|
||||
[ompi_cv_asm_powerpc_r_reg=0],
|
||||
[OMPI_TRY_ASSEMBLE([$ompi_cv_asm_text
|
||||
[opal_cv_asm_powerpc_r_reg=0],
|
||||
[OMPI_TRY_ASSEMBLE([$opal_cv_asm_text
|
||||
addi r1,r1,0],
|
||||
[ompi_cv_asm_powerpc_r_reg=1],
|
||||
[opal_cv_asm_powerpc_r_reg=1],
|
||||
[AC_MSG_ERROR([Can not determine how to use PPC registers])])])
|
||||
if test "$ompi_cv_asm_powerpc_r_reg" = "1" ; then
|
||||
if test "$opal_cv_asm_powerpc_r_reg" = "1" ; then
|
||||
AC_MSG_RESULT([yes])
|
||||
else
|
||||
AC_MSG_RESULT([no])
|
||||
fi
|
||||
|
||||
AC_DEFINE_UNQUOTED([OMPI_POWERPC_R_REGISTERS],
|
||||
[$ompi_cv_asm_powerpc_r_reg],
|
||||
AC_DEFINE_UNQUOTED([OPAL_POWERPC_R_REGISTERS],
|
||||
[$opal_cv_asm_powerpc_r_reg],
|
||||
[Whether r notation is used for ppc registers])
|
||||
])dnl
|
||||
|
||||
@ -496,12 +496,12 @@ AC_DEFUN([OMPI_CHECK_POWERPC_64BIT],[
|
||||
case $host in
|
||||
*-darwin*)
|
||||
ppc64_result=0
|
||||
if test "$ompi_cv_asm_powerpc_r_reg" = "1" ; then
|
||||
if test "$opal_cv_asm_powerpc_r_reg" = "1" ; then
|
||||
ldarx_asm=" ldarx r1,r1,r1";
|
||||
else
|
||||
ldarx_asm=" ldarx 1,1,1";
|
||||
fi
|
||||
OMPI_TRY_ASSEMBLE([$ompi_cv_asm_text
|
||||
OMPI_TRY_ASSEMBLE([$opal_cv_asm_text
|
||||
$ldarx_asm],
|
||||
[ppc64_result=1],
|
||||
[ppc64_result=0])
|
||||
@ -531,7 +531,7 @@ dnl #################################################################
|
||||
AC_DEFUN([OMPI_CHECK_SPARCV8PLUS],[
|
||||
AC_MSG_CHECKING([if have Sparc v8+/v9 support])
|
||||
sparc_result=0
|
||||
OMPI_TRY_ASSEMBLE([$ompi_cv_asm_text
|
||||
OMPI_TRY_ASSEMBLE([$opal_cv_asm_text
|
||||
casa [%o0] 0x80, %o1, %o2],
|
||||
[sparc_result=1],
|
||||
[sparc_result=0])
|
||||
@ -612,16 +612,16 @@ return ret;]]),
|
||||
AC_MSG_RESULT([$asm_result])
|
||||
|
||||
if test "$asm_result" = "yes" ; then
|
||||
OMPI_C_GCC_INLINE_ASSEMBLY=1
|
||||
OPAL_C_GCC_INLINE_ASSEMBLY=1
|
||||
else
|
||||
OMPI_C_GCC_INLINE_ASSEMBLY=0
|
||||
OPAL_C_GCC_INLINE_ASSEMBLY=0
|
||||
fi
|
||||
|
||||
AC_DEFINE_UNQUOTED([OMPI_C_GCC_INLINE_ASSEMBLY],
|
||||
[$OMPI_C_GCC_INLINE_ASSEMBLY],
|
||||
AC_DEFINE_UNQUOTED([OPAL_C_GCC_INLINE_ASSEMBLY],
|
||||
[$OPAL_C_GCC_INLINE_ASSEMBLY],
|
||||
[Whether C compiler supports GCC style inline assembly])
|
||||
|
||||
unset OMPI_C_GCC_INLINE_ASSEMBLY assembly asm_result
|
||||
unset OPAL_C_GCC_INLINE_ASSEMBLY assembly asm_result
|
||||
])dnl
|
||||
|
||||
AC_DEFUN([OMPI_CHECK_INLINE_CXX_GCC],[
|
||||
@ -700,16 +700,16 @@ return 0;]]),
|
||||
AC_MSG_RESULT([$asm_result])
|
||||
|
||||
if test "$asm_result" = "yes" ; then
|
||||
OMPI_C_DEC_INLINE_ASSEMBLY=1
|
||||
OPAL_C_DEC_INLINE_ASSEMBLY=1
|
||||
else
|
||||
OMPI_C_DEC_INLINE_ASSEMBLY=0
|
||||
OPAL_C_DEC_INLINE_ASSEMBLY=0
|
||||
fi
|
||||
|
||||
AC_DEFINE_UNQUOTED([OMPI_C_DEC_INLINE_ASSEMBLY],
|
||||
[$OMPI_C_DEC_INLINE_ASSEMBLY],
|
||||
AC_DEFINE_UNQUOTED([OPAL_C_DEC_INLINE_ASSEMBLY],
|
||||
[$OPAL_C_DEC_INLINE_ASSEMBLY],
|
||||
[Whether C compiler supports DEC style inline assembly])
|
||||
|
||||
unset OMPI_C_DEC_INLINE_ASSEMBLY asm_result
|
||||
unset OPAL_C_DEC_INLINE_ASSEMBLY asm_result
|
||||
])dnl
|
||||
|
||||
AC_DEFUN([OMPI_CHECK_INLINE_CXX_DEC],[
|
||||
@ -753,7 +753,7 @@ AC_DEFUN([OMPI_CHECK_INLINE_C_XLC],[
|
||||
|
||||
AC_MSG_CHECKING([if $CC supports XLC inline assembly])
|
||||
|
||||
OMPI_C_XLC_INLINE_ASSEMBLY=0
|
||||
OPAL_C_XLC_INLINE_ASSEMBLY=0
|
||||
asm_result="no"
|
||||
if test "$CC" = "xlc" ; then
|
||||
OMPI_XLC_INLINE_ASSEMBLY=1
|
||||
@ -761,11 +761,11 @@ AC_DEFUN([OMPI_CHECK_INLINE_C_XLC],[
|
||||
fi
|
||||
|
||||
AC_MSG_RESULT([$asm_result])
|
||||
AC_DEFINE_UNQUOTED([OMPI_C_XLC_INLINE_ASSEMBLY],
|
||||
[$OMPI_C_XLC_INLINE_ASSEMBLY],
|
||||
AC_DEFINE_UNQUOTED([OPAL_C_XLC_INLINE_ASSEMBLY],
|
||||
[$OPAL_C_XLC_INLINE_ASSEMBLY],
|
||||
[Whether C compiler supports XLC style inline assembly])
|
||||
|
||||
unset OMPI_C_XLC_INLINE_ASSEMBLY
|
||||
unset OPAL_C_XLC_INLINE_ASSEMBLY
|
||||
])dnl
|
||||
|
||||
AC_DEFUN([OMPI_CHECK_INLINE_CXX_XLC],[
|
||||
@ -792,10 +792,10 @@ dnl #################################################################
|
||||
dnl
|
||||
dnl OMPI_CONFIG_ASM
|
||||
dnl
|
||||
dnl DEFINE OMPI_ASSEMBLY_ARCH to something in sys/architecture.h
|
||||
dnl DEFINE OMPI_ASSEMBLY_FORMAT to string containing correct
|
||||
dnl DEFINE OPAL_ASSEMBLY_ARCH to something in sys/architecture.h
|
||||
dnl DEFINE OPAL_ASSEMBLY_FORMAT to string containing correct
|
||||
dnl format for assembly (not user friendly)
|
||||
dnl SUBST OMPI_ASSEMBLY_FORMAT to string containing correct
|
||||
dnl SUBST OPAL_ASSEMBLY_FORMAT to string containing correct
|
||||
dnl format for assembly (not user friendly)
|
||||
dnl
|
||||
dnl #################################################################
|
||||
@ -843,7 +843,7 @@ AC_DEFUN([OMPI_CONFIG_ASM],[
|
||||
AC_MSG_RESULT([no])
|
||||
want_smp_locks=0
|
||||
fi
|
||||
AC_DEFINE_UNQUOTED([OMPI_WANT_SMP_LOCKS], [$want_smp_locks],
|
||||
AC_DEFINE_UNQUOTED([OPAL_WANT_SMP_LOCKS], [$want_smp_locks],
|
||||
[whether we want to have smp locks in atomic ops or not])
|
||||
|
||||
if test "$ompi_cv_c_compiler_vendor" = "microsoft" ; then
|
||||
@ -863,7 +863,7 @@ AC_DEFUN([OMPI_CONFIG_ASM],[
|
||||
# find our architecture for purposes of assembly stuff
|
||||
ompi_cv_asm_arch="UNSUPPORTED"
|
||||
OMPI_GCC_INLINE_ASSIGN=""
|
||||
OMPI_ASM_SUPPORT_64BIT=0
|
||||
OPAL_ASM_SUPPORT_64BIT=0
|
||||
case "${host}" in
|
||||
i?86-*|x86_64*)
|
||||
if test "$ac_cv_sizeof_long" = "4" ; then
|
||||
@ -871,19 +871,19 @@ AC_DEFUN([OMPI_CONFIG_ASM],[
|
||||
else
|
||||
ompi_cv_asm_arch="AMD64"
|
||||
fi
|
||||
OMPI_ASM_SUPPORT_64BIT=1
|
||||
OPAL_ASM_SUPPORT_64BIT=1
|
||||
OMPI_GCC_INLINE_ASSIGN='"movl [$]0, %0" : "=&r"(ret)'
|
||||
;;
|
||||
|
||||
ia64-*)
|
||||
ompi_cv_asm_arch="IA64"
|
||||
OMPI_ASM_SUPPORT_64BIT=1
|
||||
OPAL_ASM_SUPPORT_64BIT=1
|
||||
OMPI_GCC_INLINE_ASSIGN='"mov %0=r0\n;;\n" : "=&r"(ret)'
|
||||
;;
|
||||
|
||||
alpha-*|alphaev[[4-8]]-*|alphaev56-*|alphaev6[[78]]-*)
|
||||
ompi_cv_asm_arch="ALPHA"
|
||||
OMPI_ASM_SUPPORT_64BIT=1
|
||||
OPAL_ASM_SUPPORT_64BIT=1
|
||||
OMPI_GCC_INLINE_ASSIGN='"bis [$]31,[$]31,%0" : "=&r"(ret)'
|
||||
;;
|
||||
|
||||
@ -891,7 +891,7 @@ AC_DEFUN([OMPI_CONFIG_ASM],[
|
||||
# Should really find some way to make sure that we are on
|
||||
# a MIPS III machine (r4000 and later)
|
||||
ompi_cv_asm_arch="MIPS"
|
||||
OMPI_ASM_SUPPORT_64BIT=1
|
||||
OPAL_ASM_SUPPORT_64BIT=1
|
||||
OMPI_GCC_INLINE_ASSIGN='"or %0,[$]0,[$]0" : "=&r"(ret)'
|
||||
;;
|
||||
|
||||
@ -904,9 +904,9 @@ AC_DEFUN([OMPI_CONFIG_ASM],[
|
||||
# compiling in 32 bit mode (and therefore should assume
|
||||
# sizeof(long) == 4), we can use the 64 bit test and set
|
||||
# operations.
|
||||
OMPI_CHECK_POWERPC_64BIT(OMPI_ASM_SUPPORT_64BIT=1)
|
||||
OMPI_CHECK_POWERPC_64BIT(OPAL_ASM_SUPPORT_64BIT=1)
|
||||
elif test "$ac_cv_sizeof_long" = "8" ; then
|
||||
OMPI_ASM_SUPPORT_64BIT=1
|
||||
OPAL_ASM_SUPPORT_64BIT=1
|
||||
ompi_cv_asm_arch="POWERPC64"
|
||||
else
|
||||
AC_MSG_ERROR([Could not determine PowerPC word size: $ac_cv_sizeof_long])
|
||||
@ -922,7 +922,7 @@ AC_DEFUN([OMPI_CONFIG_ASM],[
|
||||
have_v8plus=0
|
||||
OMPI_CHECK_SPARCV8PLUS([have_v8plus=1])
|
||||
if test "$have_v8plus" = "0" ; then
|
||||
OMPI_ASM_SUPPORT_64BIT=0
|
||||
OPAL_ASM_SUPPORT_64BIT=0
|
||||
ompi_cv_asm_arch="SPARC"
|
||||
AC_MSG_WARN([Sparc v8 target is not supported in this release of Open MPI.])
|
||||
AC_MSG_WARN([You must specify the target architecture v8plus])
|
||||
@ -931,12 +931,12 @@ AC_MSG_WARN([FFLAGS, and FCFLAGS to compile Open MPI in 32 bit mode on])
|
||||
AC_MSG_WARN([Sparc processors])
|
||||
AC_MSG_ERROR([Can not continue.])
|
||||
else
|
||||
OMPI_ASM_SUPPORT_64BIT=1
|
||||
OPAL_ASM_SUPPORT_64BIT=1
|
||||
ompi_cv_asm_arch="SPARCV9_32"
|
||||
fi
|
||||
|
||||
elif test "$ac_cv_sizeof_long" = "8" ; then
|
||||
OMPI_ASM_SUPPORT_64BIT=1
|
||||
OPAL_ASM_SUPPORT_64BIT=1
|
||||
ompi_cv_asm_arch="SPARCV9_64"
|
||||
else
|
||||
AC_MSG_ERROR([Could not determine Sparc word size: $ac_cv_sizeof_long])
|
||||
@ -949,10 +949,10 @@ AC_MSG_ERROR([Can not continue.])
|
||||
;;
|
||||
esac
|
||||
|
||||
AC_DEFINE_UNQUOTED([OMPI_ASM_SUPPORT_64BIT],
|
||||
[$OMPI_ASM_SUPPORT_64BIT],
|
||||
AC_DEFINE_UNQUOTED([OPAL_ASM_SUPPORT_64BIT],
|
||||
[$OPAL_ASM_SUPPORT_64BIT],
|
||||
[Whether we can do 64bit assembly operations or not. Should not be used outside of the assembly header files])
|
||||
AC_SUBST([OMPI_ASM_SUPPORT_64BIT])
|
||||
AC_SUBST([OPAL_ASM_SUPPORT_64BIT])
|
||||
|
||||
#
|
||||
# figure out if we need any special function start / stop code
|
||||
@ -977,37 +977,37 @@ AC_MSG_ERROR([Can not continue.])
|
||||
# format:
|
||||
# config_file-text-global-label_suffix-gsym-lsym-type-size-align_log-ppc_r_reg-64_bit-gnu_stack
|
||||
asm_format="${ompi_asm_arch_config}"
|
||||
asm_format="${asm_format}-${ompi_cv_asm_text}-${ompi_cv_asm_global}"
|
||||
asm_format="${asm_format}-${ompi_cv_asm_label_suffix}-${ompi_cv_asm_gsym}"
|
||||
asm_format="${asm_format}-${ompi_cv_asm_lsym}"
|
||||
asm_format="${asm_format}-${ompi_cv_asm_type}-${ompi_asm_size}"
|
||||
asm_format="${asm_format}-${opal_cv_asm_text}-${opal_cv_asm_global}"
|
||||
asm_format="${asm_format}-${opal_cv_asm_label_suffix}-${opal_cv_asm_gsym}"
|
||||
asm_format="${asm_format}-${opal_cv_asm_lsym}"
|
||||
asm_format="${asm_format}-${opal_cv_asm_type}-${opal_asm_size}"
|
||||
asm_format="${asm_format}-${ompi_asm_align_log_result}"
|
||||
if test "$ompi_cv_asm_arch" = "POWERPC32" -o "$ompi_cv_asm_arch" = "POWERPC64" ; then
|
||||
asm_format="${asm_format}-${ompi_cv_asm_powerpc_r_reg}"
|
||||
asm_format="${asm_format}-${opal_cv_asm_powerpc_r_reg}"
|
||||
else
|
||||
asm_format="${asm_format}-1"
|
||||
fi
|
||||
asm_format="${asm_format}-${OMPI_ASM_SUPPORT_64BIT}"
|
||||
asm_format="${asm_format}-${OPAL_ASM_SUPPORT_64BIT}"
|
||||
ompi_cv_asm_format="${asm_format}-${ompi_cv_asm_gnu_stack}"
|
||||
# For the Makefile, need to escape the $ as $$. Don't display
|
||||
# this version, but make sure the Makefile gives the right thing
|
||||
# when regenerating the files because the base has been touched.
|
||||
OMPI_ASSEMBLY_FORMAT=`echo "$ompi_cv_asm_format" | sed -e 's/\\\$/\\\$\\\$/'`
|
||||
OPAL_ASSEMBLY_FORMAT=`echo "$ompi_cv_asm_format" | sed -e 's/\\\$/\\\$\\\$/'`
|
||||
|
||||
AC_MSG_CHECKING([for assembly format])
|
||||
AC_MSG_RESULT([$ompi_cv_asm_format])
|
||||
AC_DEFINE_UNQUOTED([OMPI_ASSEMBLY_FORMAT], ["$OMPI_ASSEMBLY_FORMAT"],
|
||||
AC_DEFINE_UNQUOTED([OPAL_ASSEMBLY_FORMAT], ["$OPAL_ASSEMBLY_FORMAT"],
|
||||
[Format of assembly file])
|
||||
AC_SUBST([OMPI_ASSEMBLY_FORMAT])
|
||||
AC_SUBST([OPAL_ASSEMBLY_FORMAT])
|
||||
fi # if cv_c_compiler_vendor = microsoft
|
||||
|
||||
result="OMPI_$ompi_cv_asm_arch"
|
||||
OMPI_ASSEMBLY_ARCH="$ompi_cv_asm_arch"
|
||||
OPAL_ASSEMBLY_ARCH="$ompi_cv_asm_arch"
|
||||
AC_MSG_CHECKING([for asssembly architecture])
|
||||
AC_MSG_RESULT([$ompi_cv_asm_arch])
|
||||
AC_DEFINE_UNQUOTED([OMPI_ASSEMBLY_ARCH], [$result],
|
||||
AC_DEFINE_UNQUOTED([OPAL_ASSEMBLY_ARCH], [$result],
|
||||
[Architecture type of assembly to use for atomic operations])
|
||||
AC_SUBST([OMPI_ASSEMBLY_ARCH])
|
||||
AC_SUBST([OPAL_ASSEMBLY_ARCH])
|
||||
|
||||
OMPI_ASM_FIND_FILE
|
||||
|
||||
@ -1089,9 +1089,9 @@ fi
|
||||
result=1
|
||||
fi
|
||||
|
||||
AC_DEFINE_UNQUOTED([OMPI_HAVE_ASM_FILE], [$result],
|
||||
AC_DEFINE_UNQUOTED([OPAL_HAVE_ASM_FILE], [$result],
|
||||
[Whether there is an atomic assembly file available])
|
||||
AM_CONDITIONAL([OMPI_HAVE_ASM_FILE], [test "$result" = "1"])
|
||||
AM_CONDITIONAL([OPAL_HAVE_ASM_FILE], [test "$result" = "1"])
|
||||
|
||||
OMPI_ASM_FILE=$ompi_cv_asm_file
|
||||
AC_SUBST(OMPI_ASM_FILE)
|
||||
|
@ -30,9 +30,9 @@ AC_DEFUN([OMPI_CONFIG_THREADS],[
|
||||
#
|
||||
|
||||
# create templates
|
||||
AH_TEMPLATE([OMPI_HAVE_SOLARIS_THREADS],
|
||||
AH_TEMPLATE([OPAL_HAVE_SOLARIS_THREADS],
|
||||
[Do we have native Solaris threads])
|
||||
AH_TEMPLATE([OMPI_HAVE_POSIX_THREADS],
|
||||
AH_TEMPLATE([OPAL_HAVE_POSIX_THREADS],
|
||||
[Do we have POSIX threads])
|
||||
|
||||
#
|
||||
@ -117,13 +117,13 @@ AC_MSG_RESULT($THREAD_TYPE)
|
||||
#
|
||||
# Blah - this should be made better, but I don't know how...
|
||||
#
|
||||
AH_TEMPLATE([OMPI_THREADS_HAVE_DIFFERENT_PIDS],
|
||||
AH_TEMPLATE([OPAL_THREADS_HAVE_DIFFERENT_PIDS],
|
||||
[Do threads have different pids (pthreads on linux)])
|
||||
|
||||
if test "$THREAD_TYPE" = "solaris"; then
|
||||
AC_DEFINE(OMPI_HAVE_SOLARIS_THREADS, 1)
|
||||
AC_DEFINE(OMPI_HAVE_POSIX_THREADS, 0)
|
||||
AC_DEFINE(OMPI_THREADS_HAVE_DIFFERENT_PIDS, 0)
|
||||
AC_DEFINE(OPAL_HAVE_SOLARIS_THREADS, 1)
|
||||
AC_DEFINE(OPAL_HAVE_POSIX_THREADS, 0)
|
||||
AC_DEFINE(OPAL_THREADS_HAVE_DIFFERENT_PIDS, 0)
|
||||
|
||||
THREAD_CFLAGS="$STHREAD_CFLAGS"
|
||||
THREAD_FFLAGS="$STHREAD_FFLAGS"
|
||||
@ -133,8 +133,8 @@ if test "$THREAD_TYPE" = "solaris"; then
|
||||
THREAD_LDFLAGS="$STHREAD_LDFLAGS"
|
||||
THREAD_LIBS="$STHREAD_LIBS"
|
||||
elif test "$THREAD_TYPE" = "posix"; then
|
||||
AC_DEFINE(OMPI_HAVE_SOLARIS_THREADS, 0)
|
||||
AC_DEFINE(OMPI_HAVE_POSIX_THREADS, 1)
|
||||
AC_DEFINE(OPAL_HAVE_SOLARIS_THREADS, 0)
|
||||
AC_DEFINE(OPAL_HAVE_POSIX_THREADS, 1)
|
||||
|
||||
THREAD_CFLAGS="$PTHREAD_CFLAGS"
|
||||
THREAD_FFLAGS="$PTHREAD_FFLAGS"
|
||||
@ -146,9 +146,9 @@ elif test "$THREAD_TYPE" = "posix"; then
|
||||
|
||||
OMPI_CHECK_PTHREAD_PIDS
|
||||
else
|
||||
AC_DEFINE(OMPI_HAVE_SOLARIS_THREADS, 0)
|
||||
AC_DEFINE(OMPI_HAVE_POSIX_THREADS, 0)
|
||||
AC_DEFINE(OMPI_THREADS_HAVE_DIFFERENT_PIDS, 0)
|
||||
AC_DEFINE(OPAL_HAVE_SOLARIS_THREADS, 0)
|
||||
AC_DEFINE(OPAL_HAVE_POSIX_THREADS, 0)
|
||||
AC_DEFINE(OPAL_THREADS_HAVE_DIFFERENT_PIDS, 0)
|
||||
|
||||
TRHEAD_CFLAGS=
|
||||
THREAD_FFLAGS=
|
||||
@ -175,8 +175,8 @@ EOF
|
||||
fi
|
||||
fi
|
||||
|
||||
AM_CONDITIONAL(OMPI_HAVE_POSIX_THREADS, test "$THREAD_TYPE" = "posix")
|
||||
AM_CONDITIONAL(OMPI_HAVE_SOLARIS_THREADS, test "$THREAD_TYPE" = "solaris")
|
||||
AM_CONDITIONAL(OPAL_HAVE_POSIX_THREADS, test "$THREAD_TYPE" = "posix")
|
||||
AM_CONDITIONAL(OPAL_HAVE_SOLARIS_THREADS, test "$THREAD_TYPE" = "solaris")
|
||||
|
||||
#
|
||||
# Now configure the whole MPI and progress thread gorp
|
||||
@ -191,27 +191,27 @@ if test "$enable_mpi_threads" = "" ; then
|
||||
dnl # no argument given either way. Default to whether
|
||||
dnl # we have threads or not
|
||||
dnl if test "$THREAD_TYPE" != "none" ; then
|
||||
dnl OMPI_ENABLE_MPI_THREADS=1
|
||||
dnl OPAL_ENABLE_MPI_THREADS=1
|
||||
dnl enable_mpi_threads="yes"
|
||||
dnl else
|
||||
dnl OMPI_ENABLE_MPI_THREADS=0
|
||||
dnl OPAL_ENABLE_MPI_THREADS=0
|
||||
dnl enable_mpi_threads="no"
|
||||
dnl fi
|
||||
# no argument - default to no
|
||||
OMPI_ENABLE_MPI_THREADS=0
|
||||
OPAL_ENABLE_MPI_THREADS=0
|
||||
enable_mpi_threads="no"
|
||||
elif test "$enable_mpi_threads" = "no" ; then
|
||||
OMPI_ENABLE_MPI_THREADS=0
|
||||
OPAL_ENABLE_MPI_THREADS=0
|
||||
else
|
||||
# they want MPI threads. Make sure we have threads
|
||||
if test "$THREAD_TYPE" != "none" ; then
|
||||
OMPI_ENABLE_MPI_THREADS=1
|
||||
OPAL_ENABLE_MPI_THREADS=1
|
||||
enable_mpi_threads="yes"
|
||||
else
|
||||
AC_MSG_ERROR([User requested MPI threads, but no threading model supported])
|
||||
fi
|
||||
fi
|
||||
AC_DEFINE_UNQUOTED([OMPI_ENABLE_MPI_THREADS], [$OMPI_ENABLE_MPI_THREADS],
|
||||
AC_DEFINE_UNQUOTED([OPAL_ENABLE_MPI_THREADS], [$OPAL_ENABLE_MPI_THREADS],
|
||||
[Whether we should enable support for multiple user threads])
|
||||
AC_MSG_RESULT([$enable_mpi_threads])
|
||||
|
||||
@ -224,21 +224,21 @@ AC_ARG_ENABLE([progress-threads],
|
||||
|
||||
if test "$enable_progress_threads" = "" ; then
|
||||
# no argument given either way. Default to no.
|
||||
OMPI_ENABLE_PROGRESS_THREADS=0
|
||||
OPAL_ENABLE_PROGRESS_THREADS=0
|
||||
enable_progress_threads="no"
|
||||
elif test "$enable_progress_threads" = "no" ; then
|
||||
OMPI_ENABLE_PROGRESS_THREADS=0
|
||||
OPAL_ENABLE_PROGRESS_THREADS=0
|
||||
enable_progress_threads="no"
|
||||
else
|
||||
# they want threaded progress
|
||||
if test "$THREAD_TYPE" != "none" ; then
|
||||
OMPI_ENABLE_PROGRESS_THREADS=1
|
||||
OPAL_ENABLE_PROGRESS_THREADS=1
|
||||
enable_progress_threads="yes"
|
||||
else
|
||||
AC_MSG_ERROR([User requested progress threads, but no threading model supported])
|
||||
fi
|
||||
fi
|
||||
AC_DEFINE_UNQUOTED([OMPI_ENABLE_PROGRESS_THREADS], [$OMPI_ENABLE_PROGRESS_THREADS],
|
||||
AC_DEFINE_UNQUOTED([OPAL_ENABLE_PROGRESS_THREADS], [$OPAL_ENABLE_PROGRESS_THREADS],
|
||||
[Whether we should use progress threads rather than polling])
|
||||
AC_MSG_RESULT([$enable_progress_threads])
|
||||
|
||||
|
@ -95,7 +95,7 @@ if test "$WANT_MEM_DEBUG" = "0" -a -z "$enable_mem_debug" -a "$OMPI_DEVEL" = 1;
|
||||
echo "--> developer override: enable mem profiling by default"
|
||||
fi
|
||||
#################### Early development override ####################
|
||||
AC_DEFINE_UNQUOTED(OMPI_ENABLE_MEM_DEBUG, $WANT_MEM_DEBUG,
|
||||
AC_DEFINE_UNQUOTED(OPAL_ENABLE_MEM_DEBUG, $WANT_MEM_DEBUG,
|
||||
[Whether we want the memory profiling or not])
|
||||
|
||||
#
|
||||
@ -119,7 +119,7 @@ if test "$WANT_MEM_PROFILE" = "0" -a -z "$enable_mem_profile" -a "$OMPI_DEVEL" =
|
||||
echo "--> developer override: enable mem profiling by default"
|
||||
fi
|
||||
#################### Early development override ####################
|
||||
AC_DEFINE_UNQUOTED(OMPI_ENABLE_MEM_PROFILE, $WANT_MEM_PROFILE,
|
||||
AC_DEFINE_UNQUOTED(OPAL_ENABLE_MEM_PROFILE, $WANT_MEM_PROFILE,
|
||||
[Whether we want the memory profiling or not])
|
||||
|
||||
#
|
||||
@ -169,7 +169,7 @@ if test "$WANT_DEBUG" = "0"; then
|
||||
CFLAGS="-DNDEBUG $CFLAGS"
|
||||
CXXFLAGS="-DNDEBUG $CXXFLAGS"
|
||||
fi
|
||||
AC_DEFINE_UNQUOTED(OMPI_ENABLE_DEBUG, $WANT_DEBUG,
|
||||
AC_DEFINE_UNQUOTED(OPAL_ENABLE_DEBUG, $WANT_DEBUG,
|
||||
[Whether we want developer-level debugging code or not])
|
||||
|
||||
AC_ARG_ENABLE(debug-symbols,
|
||||
@ -399,7 +399,7 @@ else
|
||||
AC_MSG_RESULT([yes])
|
||||
WANT_PRETTY_PRINT_STACKTRACE=1
|
||||
fi
|
||||
AC_DEFINE_UNQUOTED([OMPI_WANT_PRETTY_PRINT_STACKTRACE],
|
||||
AC_DEFINE_UNQUOTED([OPAL_WANT_PRETTY_PRINT_STACKTRACE],
|
||||
[$WANT_PRETTY_PRINT_STACKTRACE],
|
||||
[if want pretty-print stack trace feature])
|
||||
|
||||
@ -457,12 +457,12 @@ AC_ARG_ENABLE(pty-support,
|
||||
[Enable/disable PTY support for STDIO forwarding. (default: enabled)]))
|
||||
if test "$enable_pty_support" = "no" ; then
|
||||
AC_MSG_RESULT([no])
|
||||
OMPI_ENABLE_PTY_SUPPORT=0
|
||||
OPAL_ENABLE_PTY_SUPPORT=0
|
||||
else
|
||||
AC_MSG_RESULT([yes])
|
||||
OMPI_ENABLE_PTY_SUPPORT=1
|
||||
OPAL_ENABLE_PTY_SUPPORT=1
|
||||
fi
|
||||
AC_DEFINE_UNQUOTED([OMPI_ENABLE_PTY_SUPPORT], [$OMPI_ENABLE_PTY_SUPPORT],
|
||||
AC_DEFINE_UNQUOTED([OPAL_ENABLE_PTY_SUPPORT], [$OPAL_ENABLE_PTY_SUPPORT],
|
||||
[Whether user wants PTY support or not])
|
||||
|
||||
#
|
||||
@ -478,10 +478,10 @@ AC_ARG_ENABLE([dlopen],
|
||||
if test "$enable_dlopen" = "no" ; then
|
||||
enable_mca_dso="no"
|
||||
enable_mca_static="yes"
|
||||
OMPI_ENABLE_DLOPEN_SUPPORT=0
|
||||
OPAL_ENABLE_DLOPEN_SUPPORT=0
|
||||
AC_MSG_RESULT([no])
|
||||
else
|
||||
OMPI_ENABLE_DLOPEN_SUPPORT=1
|
||||
OPAL_ENABLE_DLOPEN_SUPPORT=1
|
||||
AC_MSG_RESULT([yes])
|
||||
fi
|
||||
|
||||
@ -501,7 +501,7 @@ else
|
||||
AC_MSG_RESULT([no])
|
||||
ompi_want_heterogeneous=0
|
||||
fi
|
||||
AC_DEFINE_UNQUOTED([OMPI_ENABLE_HETEROGENEOUS_SUPPORT],
|
||||
AC_DEFINE_UNQUOTED([OPAL_ENABLE_HETEROGENEOUS_SUPPORT],
|
||||
[$ompi_want_heterogeneous],
|
||||
[Enable features required for heterogeneous support])
|
||||
|
||||
@ -655,7 +655,7 @@ if test "$enable_per_user_config_files" = "no" ; then
|
||||
else
|
||||
result=1
|
||||
fi
|
||||
AC_DEFINE_UNQUOTED([OMPI_WANT_HOME_CONFIG_FILES], [$result],
|
||||
AC_DEFINE_UNQUOTED([OPAL_WANT_HOME_CONFIG_FILES], [$result],
|
||||
[Enable per-user config files])
|
||||
|
||||
#
|
||||
|
@ -96,7 +96,7 @@ AC_SUBST(CLEANFILES)
|
||||
#
|
||||
|
||||
AC_CANONICAL_HOST
|
||||
AC_DEFINE_UNQUOTED(OMPI_ARCH, "$host", [OMPI architecture string])
|
||||
AC_DEFINE_UNQUOTED(OPAL_ARCH, "$host", [OMPI architecture string])
|
||||
|
||||
#
|
||||
# See if we can find an old installation of OMPI to overwrite
|
||||
|
@ -228,7 +228,7 @@ AC_DEFUN([OMPI_SETUP_CC],[
|
||||
else
|
||||
have_builtin_expect=0
|
||||
fi
|
||||
AC_DEFINE_UNQUOTED([OMPI_C_HAVE_BUILTIN_EXPECT], [$have_builtin_expect],
|
||||
AC_DEFINE_UNQUOTED([OPAL_C_HAVE_BUILTIN_EXPECT], [$have_builtin_expect],
|
||||
[Whether C compiler supports __builtin_expect])
|
||||
|
||||
# see if the C compiler supports __builtin_prefetch
|
||||
@ -244,7 +244,7 @@ AC_DEFUN([OMPI_SETUP_CC],[
|
||||
else
|
||||
have_builtin_prefetch=0
|
||||
fi
|
||||
AC_DEFINE_UNQUOTED([OMPI_C_HAVE_BUILTIN_PREFETCH], [$have_builtin_prefetch],
|
||||
AC_DEFINE_UNQUOTED([OPAL_C_HAVE_BUILTIN_PREFETCH], [$have_builtin_prefetch],
|
||||
[Whether C compiler supports __builtin_prefetch])
|
||||
|
||||
# Preload the optflags for the case where the user didn't specify
|
||||
@ -320,9 +320,9 @@ AC_DEFUN([_OMPI_PROG_CC],[
|
||||
AC_PROG_CC
|
||||
BASECC="`basename $CC`"
|
||||
CFLAGS="$ompi_cflags_save"
|
||||
AC_DEFINE_UNQUOTED(OMPI_CC, "$CC", [OMPI underlying C compiler])
|
||||
AC_DEFINE_UNQUOTED(OPAL_CC, "$CC", [OMPI underlying C compiler])
|
||||
set dummy $CC
|
||||
ompi_cc_argv0=[$]2
|
||||
OMPI_WHICH([$ompi_cc_argv0], [OMPI_CC_ABSOLUTE])
|
||||
AC_SUBST(OMPI_CC_ABSOLUTE)
|
||||
OMPI_WHICH([$ompi_cc_argv0], [OPAL_CC_ABSOLUTE])
|
||||
AC_SUBST(OPAL_CC_ABSOLUTE)
|
||||
])
|
||||
|
68
configure.ac
68
configure.ac
@ -266,18 +266,18 @@ fi
|
||||
# Check for type alignments
|
||||
#
|
||||
|
||||
OMPI_C_GET_ALIGNMENT(char, OMPI_ALIGNMENT_CHAR)
|
||||
OMPI_C_GET_ALIGNMENT(short, OMPI_ALIGNMENT_SHORT)
|
||||
OMPI_C_GET_ALIGNMENT(char, OPAL_ALIGNMENT_CHAR)
|
||||
OMPI_C_GET_ALIGNMENT(short, OPAL_ALIGNMENT_SHORT)
|
||||
OMPI_C_GET_ALIGNMENT(wchar_t, OMPI_ALIGNMENT_WCHAR)
|
||||
OMPI_C_GET_ALIGNMENT(int, OMPI_ALIGNMENT_INT)
|
||||
OMPI_C_GET_ALIGNMENT(long, OMPI_ALIGNMENT_LONG)
|
||||
OMPI_C_GET_ALIGNMENT(int, OPAL_ALIGNMENT_INT)
|
||||
OMPI_C_GET_ALIGNMENT(long, OPAL_ALIGNMENT_LONG)
|
||||
if test $ac_cv_type_long_long = yes; then
|
||||
OMPI_C_GET_ALIGNMENT(long long, OMPI_ALIGNMENT_LONG_LONG)
|
||||
OMPI_C_GET_ALIGNMENT(long long, OPAL_ALIGNMENT_LONG_LONG)
|
||||
fi
|
||||
OMPI_C_GET_ALIGNMENT(float, OMPI_ALIGNMENT_FLOAT)
|
||||
OMPI_C_GET_ALIGNMENT(double, OMPI_ALIGNMENT_DOUBLE)
|
||||
if test $ac_cv_type_long_double = yes; then
|
||||
OMPI_C_GET_ALIGNMENT(long double, OMPI_ALIGNMENT_LONG_DOUBLE)
|
||||
OMPI_C_GET_ALIGNMENT(long double, OPAL_ALIGNMENT_LONG_DOUBLE)
|
||||
fi
|
||||
OMPI_C_GET_ALIGNMENT(void *, OMPI_ALIGNMENT_VOID_P)
|
||||
|
||||
@ -290,8 +290,8 @@ AC_MSG_CHECKING(for C bool type)
|
||||
AC_COMPILE_IFELSE(AC_LANG_PROGRAM([[
|
||||
AC_INCLUDES_DEFAULT]],
|
||||
[[bool bar, foo = true; bar = foo;]]),
|
||||
[OMPI_NEED_C_BOOL=0 MSG=yes],[OMPI_NEED_C_BOOL=1 MSG=no])
|
||||
AC_DEFINE_UNQUOTED(OMPI_NEED_C_BOOL, $OMPI_NEED_C_BOOL,
|
||||
[OPAL_NEED_C_BOOL=0 MSG=yes],[OPAL_NEED_C_BOOL=1 MSG=no])
|
||||
AC_DEFINE_UNQUOTED(OPAL_NEED_C_BOOL, $OPAL_NEED_C_BOOL,
|
||||
[Whether the C compiler supports "bool" without any other help (such as <stdbool.h>)])
|
||||
AC_MSG_RESULT([$MSG])
|
||||
|
||||
@ -344,10 +344,10 @@ fi
|
||||
# separate directory.
|
||||
|
||||
if test "$WANT_WEAK_SYMBOLS" = "0"; then
|
||||
OMPI_C_HAVE_WEAK_SYMBOLS=0
|
||||
OPAL_C_HAVE_WEAK_SYMBOLS=0
|
||||
fi
|
||||
if test "$WANT_MPI_PROFILING" = "1"; then
|
||||
if test "$OMPI_C_HAVE_WEAK_SYMBOLS" = "1"; then
|
||||
if test "$OPAL_C_HAVE_WEAK_SYMBOLS" = "1"; then
|
||||
OMPI_PROFILING_COMPILE_SEPARATELY=0
|
||||
else
|
||||
OMPI_PROFILING_COMPILE_SEPARATELY=1
|
||||
@ -379,7 +379,7 @@ AM_CONDITIONAL(COMPILE_PROFILING_SEPARATELY,
|
||||
test "$OMPI_PROFILING_COMPILE_SEPARATELY" = 1)
|
||||
AC_DEFINE_UNQUOTED(OMPI_ENABLE_MPI_PROFILING, $WANT_MPI_PROFILING,
|
||||
[Whether we want MPI profiling or not])
|
||||
AC_DEFINE_UNQUOTED(OMPI_HAVE_WEAK_SYMBOLS, $OMPI_C_HAVE_WEAK_SYMBOLS,
|
||||
AC_DEFINE_UNQUOTED(OPAL_HAVE_WEAK_SYMBOLS, $OPAL_C_HAVE_WEAK_SYMBOLS,
|
||||
[Whether we have weak symbols or not])
|
||||
|
||||
|
||||
@ -676,7 +676,7 @@ AC_CHECK_HEADERS([net/if.h], [], [],
|
||||
# So first figure out if we have <stdbool.h> (i.e., check the value of
|
||||
# the macro HAVE_STDBOOL_H from the result of AC_CHECK_HEADERS,
|
||||
# above). If we do have it, then check to see if it actually works.
|
||||
# Define OMPI_USE_STDBOOL_H as approrpaite.
|
||||
# Define OPAL_USE_STDBOOL_H as approrpaite.
|
||||
AC_CHECK_HEADERS([stdbool.h], [have_stdbool_h=1], [have_stdbool_h=0])
|
||||
AC_MSG_CHECKING([if <stdbool.h> works])
|
||||
if test "$have_stdbool_h" = "1"; then
|
||||
@ -686,12 +686,12 @@ AC_INCLUDES_DEFAULT
|
||||
#include <stdbool.h>
|
||||
#endif]],
|
||||
[[bool bar, foo = true; bar = foo;]]),
|
||||
[OMPI_USE_STDBOOL_H=1 MSG=yes],[OMPI_USE_STDBOOL_H=0 MSG=no])
|
||||
[OPAL_USE_STDBOOL_H=1 MSG=yes],[OPAL_USE_STDBOOL_H=0 MSG=no])
|
||||
else
|
||||
OMPI_USE_STDBOOL_H=0
|
||||
OPAL_USE_STDBOOL_H=0
|
||||
MSG="no (don't have <stdbool.h>)"
|
||||
fi
|
||||
AC_DEFINE_UNQUOTED(OMPI_USE_STDBOOL_H, $OMPI_USE_STDBOOL_H,
|
||||
AC_DEFINE_UNQUOTED(OPAL_USE_STDBOOL_H, $OPAL_USE_STDBOOL_H,
|
||||
[Whether to use <stdbool.h> or not])
|
||||
AC_MSG_RESULT([$MSG])
|
||||
|
||||
@ -734,7 +734,7 @@ AC_EGREP_CPP(yes, [
|
||||
#ifdef SA_RESTART
|
||||
yes
|
||||
#endif ], [MSG=yes VALUE=1], [MSG=no VALUE=0])
|
||||
AC_DEFINE_UNQUOTED(OMPI_HAVE_SA_RESTART, $VALUE,
|
||||
AC_DEFINE_UNQUOTED(OPAL_HAVE_SA_RESTART, $VALUE,
|
||||
[Whether we have SA_RESTART in <signal.h> or not])
|
||||
AC_MSG_RESULT([$MSG])
|
||||
|
||||
@ -809,14 +809,14 @@ AS_IF([test "$ompi_cv_htonl_define" = "yes" -o "$ompi_have_htonl" = "yes"],
|
||||
# Make sure we can copy va_lists (need check declared, not linkable)
|
||||
#
|
||||
|
||||
AC_CHECK_DECL(va_copy, OMPI_HAVE_VA_COPY=1, OMPI_HAVE_VA_COPY=0,
|
||||
AC_CHECK_DECL(va_copy, OPAL_HAVE_VA_COPY=1, OPAL_HAVE_VA_COPY=0,
|
||||
[#include <stdarg.h>])
|
||||
AC_DEFINE_UNQUOTED(OMPI_HAVE_VA_COPY, $OMPI_HAVE_VA_COPY,
|
||||
AC_DEFINE_UNQUOTED(OPAL_HAVE_VA_COPY, $OPAL_HAVE_VA_COPY,
|
||||
[Whether we have va_copy or not])
|
||||
|
||||
AC_CHECK_DECL(__va_copy, OMPI_HAVE_UNDERSCORE_VA_COPY=1,
|
||||
OMPI_HAVE_UNDERSCORE_VA_COPY=0, [#include <stdarg.h>])
|
||||
AC_DEFINE_UNQUOTED(OMPI_HAVE_UNDERSCORE_VA_COPY, $OMPI_HAVE_UNDERSCORE_VA_COPY,
|
||||
AC_CHECK_DECL(__va_copy, OPAL_HAVE_UNDERSCORE_VA_COPY=1,
|
||||
OPAL_HAVE_UNDERSCORE_VA_COPY=0, [#include <stdarg.h>])
|
||||
AC_DEFINE_UNQUOTED(OPAL_HAVE_UNDERSCORE_VA_COPY, $OPAL_HAVE_UNDERSCORE_VA_COPY,
|
||||
[Whether we have __va_copy or not])
|
||||
|
||||
AC_CHECK_DECLS(__func__)
|
||||
@ -876,15 +876,15 @@ AC_DEFINE_UNQUOTED(OMPI_MPI_OFFSET_TYPE, $MPI_OFFSET_TYPE, [Type of MPI_Offset -
|
||||
# sizeof(void*) != sizeof(long) (64 bit Windows, apparently).
|
||||
#
|
||||
if test $ac_cv_type_ptrdiff_t = yes ; then
|
||||
ompi_ptrdiff_t="ptrdiff_t"
|
||||
opal_ptrdiff_t="ptrdiff_t"
|
||||
elif test $ac_cv_sizeof_void_p -eq $ac_cv_sizeof_long ; then
|
||||
ompi_ptrdiff_t="long"
|
||||
opal_ptrdiff_t="long"
|
||||
elif test $ac_cv_type_long_long = yes -a $ac_cv_sizeof_void_p -eq $ac_cv_sizeof_long_long ; then
|
||||
ompi_ptrdiff_t="long long"
|
||||
opal_ptrdiff_t="long long"
|
||||
else
|
||||
AC_MSG_ERROR([Could not find datatype to emulate ptrdiff_t. Cannot continue])
|
||||
fi
|
||||
AC_DEFINE_UNQUOTED([OMPI_PTRDIFF_TYPE], [$ompi_ptrdiff_t],
|
||||
AC_DEFINE_UNQUOTED([OPAL_PTRDIFF_TYPE], [$opal_ptrdiff_t],
|
||||
[type to use for ptrdiff_t])
|
||||
|
||||
#
|
||||