mutex.ac

mysql-5.0.22.tar.gz源码包

# $Id: mutex.ac,v 11.38 2002/07/25 20:07:52 sue Exp $

# POSIX pthreads tests: inter-process safe and intra-process only.
#
# We need to run a test here, because the PTHREAD_PROCESS_SHARED flag compiles
# fine on problematic systems, but won't actually work.  This is a problem for
# cross-compilation environments.  I think inter-process mutexes are as likely
# to fail in cross-compilation environments as real ones (especially since the
# likely cross-compilation environment is Linux, where inter-process mutexes
# don't currently work -- the latest estimate I've heard is Q1 2002, as part
# of IBM's NGPT package).  So:
#
# If checking for inter-process pthreads mutexes:
#	If it's local, run a test.
#	If it's a cross-compilation, fail.
#
# If the user specified pthreads mutexes and we're checking for intra-process
# mutexes only:
#	If it's local, run a test.
#	If it's a cross-compilation, run a link-test.
#
# So, the thing you can't do here is configure for inter-process POSIX pthread
# mutexes when cross-compiling.  Since we're using the GNU/Cygnus toolchain for
# cross-compilation, the target system is likely Linux or *BSD, so we're doing
# the right thing.
AC_DEFUN(AM_PTHREADS_SHARED, [
AC_TRY_RUN([
#include <pthread.h>
main() {
	pthread_cond_t cond;
	pthread_mutex_t mutex;
	pthread_condattr_t condattr;
	pthread_mutexattr_t mutexattr;
	exit (
	pthread_condattr_init(&condattr) ||
	pthread_condattr_setpshared(&condattr, PTHREAD_PROCESS_SHARED) ||
	pthread_mutexattr_init(&mutexattr) ||
	pthread_mutexattr_setpshared(&mutexattr, PTHREAD_PROCESS_SHARED) ||
	pthread_cond_init(&cond, &condattr) ||
	pthread_mutex_init(&mutex, &mutexattr) ||
	pthread_mutex_lock(&mutex) ||
	pthread_mutex_unlock(&mutex) ||
	pthread_mutex_destroy(&mutex) ||
	pthread_cond_destroy(&cond) ||
	pthread_condattr_destroy(&condattr) ||
	pthread_mutexattr_destroy(&mutexattr));
}], [db_cv_mutex="$1"],, [db_cv_mutex="no"])])
AC_DEFUN(AM_PTHREADS_PRIVATE, [
AC_TRY_RUN([
#include <pthread.h>
main() {
	pthread_cond_t cond;
	pthread_mutex_t mutex;
	pthread_condattr_t condattr;
	pthread_mutexattr_t mutexattr;
	exit (
	pthread_condattr_init(&condattr) ||
	pthread_mutexattr_init(&mutexattr) ||
	pthread_cond_init(&cond, &condattr) ||
	pthread_mutex_init(&mutex, &mutexattr) ||
	pthread_mutex_lock(&mutex) ||
	pthread_mutex_unlock(&mutex) ||
	pthread_mutex_destroy(&mutex) ||
	pthread_cond_destroy(&cond) ||
	pthread_condattr_destroy(&condattr) ||
	pthread_mutexattr_destroy(&mutexattr));
}], [db_cv_mutex="$1"],,
AC_TRY_LINK([
#include <pthread.h>],[
	pthread_cond_t cond;
	pthread_mutex_t mutex;
	pthread_condattr_t condattr;
	pthread_mutexattr_t mutexattr;
	exit (
	pthread_condattr_init(&condattr) ||
	pthread_mutexattr_init(&mutexattr) ||
	pthread_cond_init(&cond, &condattr) ||
	pthread_mutex_init(&mutex, &mutexattr) ||
	pthread_mutex_lock(&mutex) ||
	pthread_mutex_unlock(&mutex) ||
	pthread_mutex_destroy(&mutex) ||
	pthread_cond_destroy(&cond) ||
	pthread_condattr_destroy(&condattr) ||
	pthread_mutexattr_destroy(&mutexattr));
], [db_cv_mutex="$1"]))])

# Figure out mutexes for this compiler/architecture.
AC_DEFUN(AM_DEFINE_MUTEXES, [

# Mutexes we don't test for, but want the #defines to exist for
# other ports.
AH_TEMPLATE(HAVE_MUTEX_VMS, [Define to 1 to use VMS mutexes.])
AH_TEMPLATE(HAVE_MUTEX_VXWORKS, [Define to 1 to use VxWorks mutexes.])
AH_TEMPLATE(HAVE_MUTEX_WIN32, [Define to 1 to use Windows mutexes.])

AC_CACHE_CHECK([for mutexes], db_cv_mutex, [
db_cv_mutex=no

orig_libs=$LIBS

# User-specified POSIX or UI mutexes.
#
# There are two different reasons to specify mutexes: First, the application
# is already using one type of mutex and doesn't want to mix-and-match (for
# example, on Solaris, which has POSIX, UI and LWP mutexes).  Second, the
# applications POSIX pthreads mutexes don't support inter-process locking,
# but the application wants to use them anyway (for example, current Linux
# and *BSD systems).
#
# If we're on Solaris, we insist that -lthread or -lpthread be used.  The
# problem is the Solaris C library has UI/POSIX interface stubs, but they're
# broken, configuring them for inter-process mutexes doesn't return an error,
# but it doesn't work either.   Otherwise, we try first without the library
# and then with it: there's some information that SCO/UnixWare/OpenUNIX needs
# this. [#4950]
#
# Test for LWP threads before testing for UI/POSIX threads, we prefer them
# on Solaris.  There's a bug in SunOS 5.7 where applications get pwrite, not
# pwrite64, if they load the C library before the appropriate threads library,
# e.g., tclsh using dlopen to load the DB library.  By using LWP threads we
# avoid answering lots of user questions, not to mention the bugs.
if test "$db_cv_posixmutexes" = yes; then
	case "$host_os" in
	solaris*)
		db_cv_mutex="posix_library_only";;
	*)
		db_cv_mutex="posix_only";;
	esac
fi

if test "$db_cv_uimutexes" = yes; then
	case "$host_os" in
	solaris*)
		db_cv_mutex="ui_library_only";;
	*)
		db_cv_mutex="ui_only";;
	esac
fi

# LWP threads: _lwp_XXX
if test "$db_cv_mutex" = no; then
AC_TRY_LINK([
#include <synch.h>],[
	static lwp_mutex_t mi = SHAREDMUTEX;
	static lwp_cond_t ci = SHAREDCV;
	lwp_mutex_t mutex = mi;
	lwp_cond_t cond = ci;
	exit (
	_lwp_mutex_lock(&mutex) ||
	_lwp_mutex_unlock(&mutex));
], [db_cv_mutex="Solaris/lwp"])
fi

# UI threads: thr_XXX
#
# Try with and without the -lthread library.
if test "$db_cv_mutex" = no -o "$db_cv_mutex" = "ui_only"; then
AC_TRY_LINK([
#include <thread.h>
#include <synch.h>],[
	mutex_t mutex;
	cond_t cond;
	int type = USYNC_PROCESS;
	exit (
	mutex_init(&mutex, type, NULL) ||
	cond_init(&cond, type, NULL) ||
	mutex_lock(&mutex) ||
	mutex_unlock(&mutex));
], [db_cv_mutex="UI/threads"])
fi
if test "$db_cv_mutex" = no -o \
    "$db_cv_mutex" = "ui_only" -o "$db_cv_mutex" = "ui_library_only"; then
LIBS="$LIBS -lthread"
AC_TRY_LINK([
#include <thread.h>
#include <synch.h>],[
	mutex_t mutex;
	cond_t cond;
	int type = USYNC_PROCESS;
	exit (
	mutex_init(&mutex, type, NULL) ||
	cond_init(&cond, type, NULL) ||
	mutex_lock(&mutex) ||
	mutex_unlock(&mutex));
], [db_cv_mutex="UI/threads/library"])
LIBS="$orig_libs"
fi
if test "$db_cv_mutex" = "ui_only" -o "$db_cv_mutex" = "ui_library_only"; then
	AC_MSG_ERROR([unable to find UI mutex interfaces])
fi

# POSIX.1 pthreads: pthread_XXX
#
# Try with and without the -lpthread library.  If the user specified we use
# POSIX pthreads mutexes, and we fail to find the full interface, try and
# configure for just intra-process support.
if test "$db_cv_mutex" = no -o "$db_cv_mutex" = "posix_only"; then
	AM_PTHREADS_SHARED("POSIX/pthreads")
fi
if test "$db_cv_mutex" = no -o \
    "$db_cv_mutex" = "posix_only" -o "$db_cv_mutex" = "posix_library_only"; then
	LIBS="$LIBS -lpthread"
	AM_PTHREADS_SHARED("POSIX/pthreads/library")
	LIBS="$orig_libs"
fi
if test "$db_cv_mutex" = "posix_only"; then
	AM_PTHREADS_PRIVATE("POSIX/pthreads/private")
fi
if test "$db_cv_mutex" = "posix_only" -o \
    "$db_cv_mutex" = "posix_library_only"; then
	LIBS="$LIBS -lpthread"
	AM_PTHREADS_PRIVATE("POSIX/pthreads/library/private")
	LIBS="$orig_libs"
fi

if test "$db_cv_mutex" = "posix_only" -o \
    "$db_cv_mutex" = "posix_library_only"; then
	AC_MSG_ERROR([unable to find POSIX 1003.1 mutex interfaces])
fi

# msemaphore: HPPA only
# Try HPPA before general msem test, it needs special alignment.
if test "$db_cv_mutex" = no; then
AC_TRY_LINK([
#include <sys/mman.h>],[
#if defined(__hppa)
	typedef msemaphore tsl_t;
	msemaphore x;
	msem_init(&x, 0);
	msem_lock(&x, 0);
	msem_unlock(&x, 0);
	exit(0);
#else
	FAIL TO COMPILE/LINK
#endif
], [db_cv_mutex="HP/msem_init"])
fi

# msemaphore: AIX, OSF/1
if test "$db_cv_mutex" = no; then
AC_TRY_LINK([
#include <sys/types.h>
#include <sys/mman.h>],[
	typedef msemaphore tsl_t;
	msemaphore x;
	msem_init(&x, 0);
	msem_lock(&x, 0);
	msem_unlock(&x, 0);
	exit(0);
], [db_cv_mutex="UNIX/msem_init"])
fi

# ReliantUNIX
if test "$db_cv_mutex" = no; then
LIBS="$LIBS -lmproc"
AC_TRY_LINK([
#include <ulocks.h>],[
	typedef spinlock_t tsl_t;
	spinlock_t x;
	initspin(&x, 1);
	cspinlock(&x);
	spinunlock(&x);
], [db_cv_mutex="ReliantUNIX/initspin"])
LIBS="$orig_libs"
fi

# SCO: UnixWare has threads in libthread, but OpenServer doesn't.
if test "$db_cv_mutex" = no; then
AC_TRY_COMPILE(,[
#if defined(__USLC__)
	exit(0);
#else
	FAIL TO COMPILE/LINK
#endif
], [db_cv_mutex="SCO/x86/cc-assembly"])
fi

# abilock_t: SGI
if test "$db_cv_mutex" = no; then
AC_TRY_LINK([
#include <abi_mutex.h>],[
	typedef abilock_t tsl_t;
	abilock_t x;
	init_lock(&x);
	acquire_lock(&x);
	release_lock(&x);
], [db_cv_mutex="SGI/init_lock"])
fi

# sema_t: Solaris
# The sema_XXX calls do not work on Solaris 5.5.  I see no reason to ever
# turn this test on, unless we find some other platform that uses the old
# POSIX.1 interfaces.  (I plan to move directly to pthreads on Solaris.)
if test "$db_cv_mutex" = DOESNT_WORK; then
AC_TRY_LINK([
#include <synch.h>],[
	typedef sema_t tsl_t;
	sema_t x;
	sema_init(&x, 1, USYNC_PROCESS, NULL);
	sema_wait(&x);
	sema_post(&x);
], [db_cv_mutex="UNIX/sema_init"])
fi

# _lock_try/_lock_clear: Solaris
# On Solaris systems without Pthread or UI mutex interfaces, DB uses the