diff options
Diffstat (limited to 'ACE/m4/threads.m4')
| -rw-r--r-- | ACE/m4/threads.m4 | 334 |
1 files changed, 334 insertions, 0 deletions
diff --git a/ACE/m4/threads.m4 b/ACE/m4/threads.m4 new file mode 100644 index 00000000000..d6fc759b4c1 --- /dev/null +++ b/ACE/m4/threads.m4 @@ -0,0 +1,334 @@ +dnl ------------------------------------------------------------------------- +dnl $Id$ +dnl +dnl threads.m4 +dnl +dnl ACE M4 include file which contains ACE specific M4 macros +dnl for configuring thread support. This file is to be used +dnl with the configure script. +dnl +dnl ------------------------------------------------------------------------- + +dnl Copyright (C) 1998, 1999, 2002 Ossama Othman +dnl +dnl All Rights Reserved +dnl +dnl This library is free software; you can redistribute it and/or +dnl modify it under the current ACE distribution terms. +dnl +dnl This library is distributed in the hope that it will be useful, +dnl but WITHOUT ANY WARRANTY; without even the implied warranty of +dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + +dnl Make sure thread library exists +dnl We need to be careful when tests for other thread libraries are +dnl added that we don't screw up handling of "ace_user_enable_threads" +dnl Tests should probably be more platform specific later on. + +dnl Check for thread related libraries and compiler flags +dnl Usage: ACE_CHECK_THREADS +AC_DEFUN([ACE_CHECK_THREADS], +[ +dnl AC_REQUIRE([AC_PROG_CXX]) +dnl AC_REQUIRE([AC_PROG_CXXCPP]) +dnl AC_LANG([C++]) +dnl AC_REQUIRE([AC_LANG]) + + dnl Check if compiler accepts specific flag to enable threads + ACE_CACHE_CHECK([if compiler may need a command line thread flag], + [ace_cv_feature_may_need_thread_flag], + [ + ace_save_CXXFLAGS="$CXXFLAGS" + + ACE_CHECK_THREAD_FLAGS( + [ + ace_cv_feature_may_need_thread_flag=no + ], + [ + ace_cv_feature_may_need_thread_flag=yes + ]) + dnl Reset the flags to a consistent state. + dnl This prevents duplicate flags from being added to + dnl the C/CXXFLAGS variable. + CXXFLAGS="$ace_save_CXXFLAGS" + ], + [ + dnl The compiler/platform has no thread support linked in by default + dnl so search for a usable compiler flag to enable thread support. + dnl If no thread flag is found then the remaining tests should still + dnl figure out how to enable thread support via library checks. + ACE_SEARCH_THREAD_FLAGS( + [mt pthread pthreads mthreads threads Kthread kthread -thread_safe],,) + dnl NOTE: "-thread_safe" is correct, not "thread_safe." + dnl KAI C++ uses the flag "--thread_safe" which is why + dnl "-thread_safe" is passed as the flag to test. + ], + [ + dnl Do nothing + ]) + + dnl Check for UNIX International Threads (ACE calls this STHREADS) + dnl This used to check for thr_create(), but AIX has a semi-functional + dnl UI Threads capability that includes thr_create(). We don't want to + dnl find such a half-hearted UI Threads, so this was changed to look for + dnl a UI Threads function that AIX doesn't offer. + AS_IF([test "$ace_user_enable_uithreads" = yes], + [ AC_MSG_CHECKING([for UNIX International threads capability]) + AC_SEARCH_LIBS([mutex_lock], [thread], + [ + ace_has_sthreads=yes + AC_DEFINE([ACE_HAS_STHREADS], 1, + [Define to 1 if platform has UNIX International Threads]) + ], + [ + ace_has_sthreads=no + ]) + dnl Sometimes thr_create is actually found with explicitly linking against + dnl -lthread, so try a more "exotic" function. + AC_SEARCH_LIBS([rwlock_destroy], [thread],[],[]) + AC_MSG_RESULT([$ace_has_sthreads]) + ],[]) + + dnl Check if any thread related preprocessor flags are needed. + ACE_CHECK_THREAD_CPPFLAGS + + dnl Check for POSIX threads + ace_has_pthreads=no + AS_IF([test "$ace_user_enable_pthreads" = yes], + [ AC_MSG_CHECKING([for POSIX threads library]) + ACE_CHECK_POSIX_THREADS( + [ + ace_has_pthreads=yes + AC_DEFINE([ACE_HAS_PTHREADS], 1, + [Define to 1 if platform has POSIX threads]) + AC_MSG_RESULT([none required]) + ], + []) + + AS_IF([test "$ace_has_pthreads" != yes], + [ + ace_posix_threads_search_LIBS="$LIBS" + for ace_p in pthread pthreads c_r gthreads; do + LIBS="-l$ace_p $ace_posix_threads_search_LIBS" + ACE_CHECK_POSIX_THREADS( + [ + ace_has_pthreads=yes + AC_DEFINE([ACE_HAS_PTHREADS]) + AC_MSG_RESULT([-l$ace_p]) + break + ], + []) + done + + AS_IF([test "$ace_has_pthreads" != yes], + [ + AC_MSG_RESULT([no]) + LIBS="$ace_posix_threads_search_LIBS" + ],[]) + ], + []) + ], + [ + AC_MSG_NOTICE([Pthreads disabled by user; not checking for it]) + ]) + + dnl If we don't have any thread library, then disable threading altogether! + AS_IF([test "$ace_has_pthreads" != yes && test "$ace_has_sthreads" != yes], + [ + ace_user_enable_threads=no + ]) +]) + +dnl This macro will check that the current compiler flags do something +dnl useful in terms of thread libraries and/or functions. +dnl Usage: ACE_CHECK_THREAD_FLAGS(ACTION-IF-USABLE [, ACTION-IF-NOT-USABLE]]) +AC_DEFUN([ACE_CHECK_THREAD_FLAGS], +[ + ACE_CONVERT_WARNINGS_TO_ERRORS([ + dnl Check for UI thread support first. + + dnl Because some platforms are brain damaged enough to provide + dnl useless thread function stubs, link tests may succeed despite the + dnl fact the stubs are no-ops. This forces us to use a run-time test + dnl to get around this nuisance by checking the return value of + dnl thr_create(). The cross-compiled case will use a link-time + dnl test, instead. + dnl Furthermore, we need the implementation to be a real one, not + dnl a half-hearted attempt such as that provided on AIX 5. So, we + dnl make sure it can at least work with a mutex. + + AC_RUN_IFELSE([AC_LANG_SOURCE([[ +#include <thread.h> +#if ((THR_BOUND & THR_SUSPEND & THR_DETACHED) != 0) +# error This is a silly UI Threads implementation. +#endif + +extern "C" void * +ace_start_func (void *) +{ + mutex_t m; + mutex_init (&m, USYNC_THREAD, NULL); + mutex_lock (&m); + mutex_unlock (&m); + mutex_destroy (&m); + return 0; +} + +int +main () +{ + thread_t tid = 0; + + return thr_create (0, 0, ace_start_func, 0, 0, &tid); +} + ]])], + [$1], + [ + dnl Now check for POSIX thread support. + ACE_CHECK_POSIX_THREADS([$1],[$2]) + + ], + [ + dnl UI threads cross-compiled case + + AC_LINK_IFELSE([AC_LANG_PROGRAM([[ +#include <thread.h> + +extern "C" void * +ace_start_func (void *) +{ + return 0; +} + ]], + [[ + thread_t tid = 0; + + (void) thr_create (&tid, 0, ace_start_func, 0); + ]])], + [$1], + [$2]) + ]) + ]) +]) + +dnl Check what compiler thread flag may be used, if any, from the given list. +dnl The flag list is separated by white space. +dnl Usage: ACE_SEARCH_THREAD_FLAGS(THREAD-FLAG-LIST, +dnl [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND]) +AC_DEFUN([ACE_SEARCH_THREAD_FLAGS], +[ + AC_LANG([C++]) + AC_REQUIRE([AC_LANG]) + + ACE_CACHE_CHECK([for compiler thread flag], + [ace_cv_thread_flag_search], + [ + ace_save_CXXFLAGS="$CXXFLAGS" + + for i in $1; do + CXXFLAGS="$CXXFLAGS -$i" + + ACE_CHECK_THREAD_FLAGS( + [ + ace_cv_thread_flag_search="-$i" + + dnl A usable flag was found so break out of the loop. + break; + ], + [ + ace_cv_thread_flag_search=no + ]) + + dnl Reset the flags for the next flag check. + CXXFLAGS="$ace_save_CXXFLAGS" + done + + dnl Reset the flags to a consistent state. + dnl This prevents duplicate flags from being added to + dnl the CCXXFLAGS variable. + CXXFLAGS="$ace_save_CXXFLAGS" + ], + [ + dnl Add the found/cached thread flag to the C/CXXFLAGS variables + CXXFLAGS="$CXXFLAGS $ace_cv_thread_flag_search" + + $2 + ], + [ + $3 + ]) +]) + + +dnl Check if the compiler defines thread related preprocessor flags. +dnl If not, then provide them. +dnl Usage: ACE_CHECK_THREAD_CPPFLAGS +AC_DEFUN([ACE_CHECK_THREAD_CPPFLAGS], +[ + dnl A compile-time test is used instead of a preprocesse-time test + dnl because compiler thread flags defined in CFLAGS or CXXFLAGS + dnl should be used for this test. + AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ +#if !defined (_REENTRANT) && !defined (_THREAD_SAFE) +#error Neither _REENTRANT nor _THREAD_SAFE were defined. +THROW ME AN ERROR! +#endif + ]], [[ + int a = 0; a++; + ]])],[ + ACE_THR_CPPFLAGS= + ],[ + ACE_THR_CPPFLAGS="-D_REENTRANT -D_THREAD_SAFE" + ]) +]) + +dnl Check for POSIX threads support. +dnl Usage: ACE_CHECK_POSIX_THREADS([ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND]) +AC_DEFUN([ACE_CHECK_POSIX_THREADS], +[ + dnl Because some platforms are brain damaged enough to provide + dnl useless thread function stubs, link tests may succeed despite the + dnl fact the stubs are no-ops. This forces us to use a run-time test + dnl to get around this nuisance by checking the return value of + dnl pthread_create(). The cross-compiled case will use a link-time + dnl test, instead. + AC_RUN_IFELSE([AC_LANG_SOURCE([[ +#include <pthread.h> + +extern "C" void * +ace_start_func (void *) +{ + return 0; +} + +int +main () +{ + pthread_t tid = 0; + + return pthread_create (&tid, 0, ace_start_func, 0); +} + ]])], + [$1], + [$2], + [ + dnl POSIX threads check -- cross-compiled case + + AC_LINK_IFELSE([AC_LANG_PROGRAM([[ +#include <pthread.h> + +extern "C" void * +ace_start_func (void *) +{ + return 0; +} + ]], + [[ + pthread_t tid = 0; + + (void) pthread_create (&tid, 0, ace_start_func, 0); + ]])], + [$1], + [$2]) + ]) +]) |