ost_pthread.m4

来自「贡献一份commoncpp2,有兴趣的可以研究一下」· M4 代码 · 共 574 行 · 第 1/2 页

		#endif
		return (int)PTHREAD_MUTEXTYPE_RECURSIVE;
		],
		ost_cv_mutex_recursive="portable",
		[	
		AC_EGREP_HEADER(PTHREAD_MUTEXTYPE_RECURSIVE_NP,pthread.h,
			ost_cv_mutex_recursive=non-portable)
		AC_EGREP_HEADER(PTHREAD_MUTEX_RECURSIVE_INITIALIZER_NP, pthread.h,
			ost_cv_mutex_recursive=lthread)
		AC_EGREP_HEADER(PTHREAD_MUTEX_RECURSIVE_NP,pthread.h,
			ost_cv_mutex_recursive=linux) 
		AC_EGREP_HEADER(MUTEX_TYPE_COUNTING_FAST,pthread.h,
			ost_cv_mutex_recursive=counting)	
		])
		if test $ost_cv_mutex_recursive = "none" ; then
			if test $ost_cv_thread_library = "lthread" ; then
				ost_cv_mutex_recursive=linux
			fi
		fi
	rm -f conftest*
	])

	if test $ost_cv_mutex_recursive = "none" ; then
		AC_TRY_COMPILE(
			[#include <pthread.h>],
		 	[return MUTEX_TYPE_COUNTING_FAST;],
			ost_cv_mutex_recursive=counting)
	fi

	if test "$ost_cv_cxx_mode" = true ; then
		CXXFLAGS="$SAVE_CXXFLAGS"
		AC_LANG_RESTORE
	fi


	case $ost_cv_mutex_recursive in
	non-portable)
		AC_DEFINE(PTHREAD_MUTEXTYPE_RECURSIVE,
			PTHREAD_MUTEXTYPE_RECURSIVE_NP, [mutex type])
		;;
	linux)
		AC_DEFINE(PTHREAD_MUTEXTYPE_RECURSIVE,
			PTHREAD_MUTEX_RECURSIVE_NP)
		;;
	counting)
		AC_DEFINE(PTHREAD_MUTEXTYPE_RECURSIVE,
			MUTEX_TYPE_COUNTING_FAST)
		;;
	esac

	AC_CHECK_LIB(${ost_cv_thread_library}, pthread_mutexattr_settype,
		AC_DEFINE(HAVE_PTHREAD_MUTEXATTR_SETTYPE, [1], [has setttype]),
		[
		AC_CHECK_LIB(${ost_cv_thread_library}, pthread_mutexattr_settype_np,
			AC_DEFINE(HAVE_PTHREAD_MUTEXATTR_SETTYPE_NP, 
				[1], [has non portable settype]))
		AC_CHECK_LIB(${ost_cv_thread_library}, pthread_mutexattr_setkind_np,
			AC_DEFINE(HAVE_PTHREAD_MUTEXATTR_SETKIND_NP,
				[1], [has non portable setkind]))
		]
	)

	ost_cv_thread_rwlock=false
	AC_CHECK_LIB(${ost_cv_thread_library}, pthread_rwlock_init,[
		ost_cv_thread_rwlock=true
		AC_DEFINE(HAVE_PTHREAD_RWLOCK, [1], [has rwlock support])])

	AC_CHECK_LIB(c, pread,[
		AC_DEFINE(HAVE_PREAD_PWRITE, [1], [has pwrite])],[
		AC_CHECK_LIB(${ost_cv_thread_library}, pread,[
			AC_DEFINE(HAVE_PREAD_PWRITE, [1])],[
			AC_CHECK_LIB(c_r, pread,[AC_DEFINE(HAVE_PREAD_PWRITE)])
		])
	])

	AC_CHECK_LIB(${ost_cv_thread_library}, pthread_suspend,
		AC_DEFINE(HAVE_PTHREAD_SUSPEND, [1], [has suspend]))

	AC_CHECK_LIB(${ost_cv_thread_library}, pthread_attr_setstacksize,
		AC_DEFINE(HAVE_PTHREAD_ATTR_SETSTACKSIZE, [1], [has stack size]))

	AC_CHECK_LIB(${ost_cv_thread_library}, pthread_yield_np,
		AC_DEFINE(HAVE_PTHREAD_YIELD_NP, [1], [has np yield]),[
		AC_CHECK_LIB(${ost_cv_thread_library}, pthread_yield,
			AC_DEFINE(HAVE_PTHREAD_YIELD, [1], [has yield]),[
			AC_CHECK_LIB(${ost_cv_thread_library}, sched_yield,
				AC_DEFINE(HAVE_PTHREAD_SCHED_YIELD, [1], [has sched yield]))
			])
		])

	AC_CHECK_LIB(${ost_cv_thread_library}, pthread_cancel,[
		AC_DEFINE(HAVE_PTHREAD_CANCEL, [1], [has cancel])
	  	AC_CHECK_LIB(${ost_cv_thread_library},
			pthread_setcanceltype,
			AC_DEFINE(HAVE_PTHREAD_SETCANCELTYPE, [1], [has setcanceltype]),
			AC_CHECK_LIB($ost_cv_thread_library, pthread_setcanel,
				AC_DEFINE(HAVE_PTHREAD_SETCANCEL, [1], [has setcancel])))
		],[
		AC_CHECK_LIB(${ost_cv_thread_library},
			pthread_setcanceltype,[
			AC_DEFINE(HAVE_PTHREAD_CANCEL)
			AC_DEFINE(HAVE_PTHREAD_SETCANCELTYPE)])

		])

	AC_CHECK_LIB(${ost_cv_thread_library}, pthread_delay_np,
		AC_DEFINE(HAVE_PTHREAD_DELAY_NP, [1], [has non portable delay]))

  fi

  UNAME=`uname`
  if test "$UNAME" = "AIX" ; then
	AC_CHECK_PROG(PTHREAD_CC, cc_r, cc_r, ${CC})
	CC=$PTHREAD_CC
	AC_DEFINE(COMMON_AIX_FIXES, [1], [aix fixes needed])
  fi

AH_BOTTOM([
#ifdef HAVE_THREAD_H
#include "@thrprefix@/thread.h"
#if defined(i386) && defined(__svr4__) && !defined(__sun)
#define _THR_UNIXWARE
#endif
#if defined(__SVR4) && defined(__sun)
#define _THR_SUNOS5
#else
#if defined(__SVR4__) && defined(__SUN__)
#define _THR_SUNOS5
#endif
#endif
#endif

#ifdef HAVE_WORKING_SYS_ATOMIC_H
#include <sys/atomic.h>
#define HAVE_ATOMIC
#elif defined(HAVE_ATOMIC_AIX)
#include <sys/atomic_op.h>
#ifndef	HAVE_ATOMIC
#define	HAVE_ATOMIC
#endif
#endif

#if defined(__cplusplus)
#if defined(HAVE_GCC_BITS_ATOMIC) || defined(HAVE_GCC_CXX_BITS_ATOMIC)
#include <bits/atomicity.h>
#define HAVE_ATOMIC
#endif
#endif

#if defined(HAVE_PTHREAD_H) && ( defined(_THREAD_SAFE) || defined(_REENTRANT) )

#ifdef	__QNX__
#define	__EXT_QNX
#endif

#include <pthread.h>

#ifdef HAVE_PTHREAD_NP_H
#include <pthread_np.h>
#endif

#ifdef HAVE_SEMAPHORE_H
#include <semaphore.h>
#endif
#ifdef _POSIX_PRIORITY_SCHEDULING
#ifdef HAVE_SCHED_H
#include <sched.h>
#else
#ifdef HAVE_SYS_SCHED_H
#include <sys/sched.h>
#endif
#endif
#endif

#define __PTHREAD_H__
#ifndef PTHREAD_MUTEXTYPE_RECURSIVE
#ifdef  MUTEX_TYPE_COUNTING_FAST
#define PTHREAD_MUTEXTYPE_RECURSIVE MUTEX_TYPE_COUNTING_FAST
#endif
#endif
#ifndef PTHREAD_MUTEXTYPE_RECURSIVE
#ifdef  PTHREAD_MUTEX_RECURSIVE
#define PTHREAD_MUTEXTYPE_RECURSIVE PTHREAD_MUTEX_RECURSIVE
#endif
#endif
#ifndef HAVE_PTHREAD_MUTEXATTR_SETTYPE
#if     HAVE_PTHREAD_MUTEXATTR_SETKIND_NP
#ifndef PTHREAD_MUTEXTYPE_RECURSIVE
#define PTHREAD_MUTEXTYPE_RECURSIVE PTHREAD_MUTEX_RECURSIVE_NP
#endif
#define pthread_mutexattr_gettype(x, y) pthread_mutexattr_getkind_np(x, y)
#define pthread_mutexattr_settype(x, y) pthread_mutexattr_setkind_np(x, y)
#endif
#if     HAVE_PTHREAD_MUTEXATTR_SETTYPE_NP
#ifndef PTHREAD_MUTEXTYPE_RECURSIVE
#define PTHREAD_MUTEXTYPE_RECURSIVE PTHREAD_MUTEXTYPE_RECURSIVE_NP
#endif
#define pthread_mutexattr_settype(x, y) pthread_mutexattr_settype_np(x, y)
#define pthread_mutexattr_gettype(x, y) pthread_mutexattr_gettype_np(x, y)
#endif
#endif

#ifdef	HAVE_PTHREAD_MACH_THREAD_NP
#define	_THR_MACH
#endif

#ifndef HAVE_PTHREAD_YIELD
#ifdef	HAVE_PTHREAD_YIELD_NP
#define	pthread_yield() pthread_yield_np()
#define	HAVE_PTHREAD_YIELD
#endif
#endif

#ifndef HAVE_PTHREAD_YIELD
#ifdef HAVE_PTHREAD_SCHED_YIELD
#define pthread_yield() sched_yield()
#define HAVE_PTHREAD_YIELD
#endif
#endif

#ifndef HAVE_PTHREAD_DELAY
#ifdef HAVE_PTHREAD_DELAY_NP
#define HAVE_PTHREAD_DELAY
#define pthread_delay(x) pthread_delay_np(x)
#endif
#if defined(HAVE_PTHREAD_NANOSLEEP)
#ifndef HAVE_PTHREAD_DELAY
#define HAVE_PTHREAD_DELAY
#ifdef __FreeBSD__
#ifdef __cplusplus
extern "C" int nanosleep(const struct timespec *rqtp, struct timespec *rmtp);
#endif
#endif
#define pthread_delay(x) nanosleep(x, NULL)
#endif
#endif
#endif

#ifdef HAVE_PTHREAD_ATTR_SETSTACK
#ifndef PTHREAD_STACK_MIN
#define PTHREAD_STACK_MIN 32768
#endif
#endif

#ifndef HAVE_PTHREAD_CANCEL
#ifdef SIGCANCEL
#define CCXX_SIG_THREAD_CANCEL SIGCANCEL
#else
#define CCXX_SIG_THREAD_CANCEL SIGQUIT
#endif
#define pthread_cancel(x) pthread_kill(x, CCXX_SIG_THREAD_CANCEL)
#define	pthread_setcanceltype(x, y)
#define	pthread_setcancelstate(x, y)
#endif

#ifndef HAVE_PTHREAD_SETCANCELTYPE
#ifdef HAVE_PTHREAD_SETCANCEL
enum
{ PTHREAD_CANCEL_ASYNCHRONOUS = CANCEL_ON,
  PTHREAD_CANCEL_DEFERRED = CANCEL_OFF};
enum
{ PTHREAD_CANCEL_ENABLE = CANCEL_ON,
  PTHREAD_CANCEL_DISABLE = CANCEL_OFF};
#define pthread_setcancelstate(x, y) \
        (y == NULL) ? pthread_setcancel(x) : *y = pthread_setcancel
#define pthread_setcanceltype(x, y) \
        (y == NULL) ? pthread_setasynccancel(x) | *y = pthread_setasynccancel(x)
#else
#define pthread_setcanceltype(x, y)
#define pthread_setcancelstate(x, y)
#endif
#endif

#ifdef  _AIX
#ifdef  HAVE_PTHREAD_SUSPEND
#undef  HAVE_PTHREAD_SUSPEND
#endif
#endif

#endif


	])

])