# Process this file with autoconf to produce a configure script.

# File: configure.in

# cross compile sample

# ARCH=mips CC=scgcc ./configure --with-arch=mips --host=mips64el-gentoo-linux-gnu- --with-ffsll --with-libpfm4 --with-perf-events --with-virtualtimer=times --with-walltimer=gettimeofday --with-tls=__thread --with-CPU=mips

# cross compiling should work differently...

AC_PREREQ(2.59)

AC_INIT(PAPI, 5.6.0.0, ptools-perfapi@icl.utk.edu)

AC_CONFIG_SRCDIR([papi.c])

AC_CONFIG_HEADER([config.h])

AC_DEFUN([AS_AC_EXPAND],

         [EXP_VAR=[$1]

          FROM_VAR=[$2]

          prefix_save=$prefix

          exec_prefix_save=$exec_prefix

          if test "x$prefix" = "xNONE"; then

            prefix="$ac_default_prefix"

          fi

          if test "x$exec_prefix" = "xNONE"; then

            exec_prefix=$prefix

          fi

          full_var="$FROM_VAR"

          while true; 

            do

              new_full_var="`eval echo $full_var`"

              if test "x$new_full_var" = "x$full_var"; then 

                break; 

              fi

              full_var=$new_full_var

            done

          full_var=$new_full_var

          AC_DEFINE_UNQUOTED([$1], "$full_var")

          prefix=$prefix_save

          exec_prefix=$exec_prefix_save ])

AC_MSG_CHECKING(for architecture)

AC_ARG_WITH(arch,

	       [  --with-arch=<arch>		Specify architecture (uname -m)],

	       [arch=$withval],

	       [arch=`uname -m`])

AC_MSG_RESULT($arch)

AC_ARG_WITH(bitmode,

            [  --with-bitmode=<32,64>		Specify bit mode of library],

            [bitmode=$withval])

AC_MSG_CHECKING(for OS)

AC_ARG_WITH(OS,

           [  --with-OS=<os>       		Specify operating system],

           [OS=$withval],

	       [OS="`uname | tr '[A-Z]' '[a-z]'`"

            if (test "$OS" = "SunOS" || test "$OS" = "sunos"); then

              OS=solaris

            fi ])

AC_MSG_RESULT($OS)

AC_MSG_CHECKING(for OS version)

AC_ARG_WITH(OSVER,

           [  --with-OSVER=<ver>		Specify operating system version],

           [OSVER=$withval],

	       [if test "$OS" != "bgp" -o "$OS" != "bgq"; then

              OSVER="`uname -r`"

            fi ])

AC_MSG_RESULT($OSVER)

AC_MSG_CHECKING(for perf_event workaround level)

AC_ARG_WITH(assumed_kernel,

		[  --with-assumed-kernel=<ver>	Assume kernel version is <ver> for purposes of workarounds],

		[assumed_kernel=$withval; CFLAGS="$CFLAGS -DASSUME_KERNEL=\\\"$with_assumed_kernel\\\""],

                [assumed_kernel="autodetect"]

		)		

AC_MSG_RESULT($assumed_kernel)

AC_MSG_CHECKING([for if MIC should be used])

		AC_ARG_WITH(mic,

						[ --with-mic To compile for Intel MIC ],

						[MIC=yes

						tls=__thread

						virtualtimer=cputime_id

						perf_events=yes

						walltimer=clock_realtime_hr

						ffsll=no

						cross_compiling=yes

						arch=k1om],

						[MIC=no])

AC_MSG_RESULT($MIC)

AC_SUBST(MIC)

CFLAGS="$CFLAGS -g"

#If not set, set FFLAGS to null to prevent AC_PROG_F77 from defaulting it to -g -O2

if test "x$FFLAGS" = "x"; then

  FFLAGS=""

fi

OPTFLAGS="-O2" 

TOPTFLAGS="-O1" 

AC_PROG_CC([xlc icc gcc cc])

AC_PROG_F77([xlf ifort gfortran f95 f90 f77])

if test "x$F77" = "x"; then

   F77=

fi

AC_CHECK_PROG( [MPICC], mpicc, [mpicc], [])

# Lets figure out what CC actually is...

# Used in later checks to set compiler specific options

if `$CC -V 2>&1 | grep '^Intel(R) C' >/dev/null 2>&1` ; then

	CC_COMMON_NAME="icc"

elif `$CC -v 2>&1 | grep 'gcc version' >/dev/null 2>&1` ; then

	CC_COMMON_NAME="gcc"  

elif `$CC -qversion 2>&1 | grep 'IBM XL C' >/dev/null 2>&1;; then

	CC_COMMON_NAME="xlc"

else

	CC_COMMON_NAME="unknown"

fi

#prevent icc warnings about overriding optimization settings set by AC_PROG_CC

# remark #869: parameter was never referenced 

# remark #271: trailing comma is nonstandard

if test "$CC_COMMON_NAME" = "icc"; then

  CFLAGS="$CFLAGS -diag-disable 188,869,271"

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

     CC="$CC -mmic -fPIC"

  fi

fi

if test "$F77" = "ifort" -a "$MIC" = "yes"; then

  F77="$F77 -mmic -fPIC"

fi

AC_PROG_AWK

AC_PROG_CPP

AC_PROG_LN_S

AC_PROG_MAKE_SET

AC_PROG_RANLIB   

AC_GNU_SOURCE

AC_HEADER_STDC

AC_C_INLINE

AC_HEADER_TIME

AC_CHECK_HEADERS([sys/time.h c_asm.h intrinsics.h mach/mach_time.h sched.h])

AC_CHECK_FUNCS([gethrtime read_real_time time_base_to_time clock_gettime mach_absolute_time sched_getcpu])

#

# Check if the system provides dl* symbols without -ldl, and if not,

# check for -ldl existance.

#

AC_MSG_CHECKING([for dlopen and dlerror symbols in base system])

AC_TRY_LINK([#include <dlfcn.h>],

	[void *p = dlopen ("", 0); char *c = dlerror();],

	[dlsymbols_in_base="yes"], [dlsymbols_in_base="no"])

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

	AC_MSG_RESULT([found])

	LDL=""

else

	AC_MSG_RESULT([not found])

	AC_MSG_CHECKING([for dlopen and dlerror symbols in -ldl])

	SAVED_LIBS=${LIBS}

	LIBS="${LIBS} -ldl"

	AC_TRY_LINK([#include <dlfcn.h>],

		[void *p = dlopen ("", 0); char *c = dlerror();],

		[has_ldl="yes"], [has_ldl="no"])

	LIBS=${SAVED_LIBS}

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

		AC_MSG_RESULT([found])

  	LDL="-ldl"

	else

		AC_MSG_ERROR([cannot find dlopen and dlerror symbols neither in the base system libraries nor in -ldl])

	fi

fi

AC_SUBST(LDL)

if test "$OS" = "CLE"; then

  virtualtimer=times

  tls=__thread

  walltimer=cycle

  ffsll=yes

  cross_compiling=yes

  STATIC="-static"

  # _rtc is only defined when using the Cray compiler

  AC_MSG_CHECKING([for _rtc intrinsic])

  rtc_ok=yes

  AC_TRY_LINK([#ifdef HAVE_INTRINSICS_H

               #include <intrinsics.h>

               #endif], [_rtc()], [AC_DEFINE(HAVE__RTC,1,[Define for _rtc() intrinsic.])], 

              [rtc_ok=no

               AC_DEFINE(NO_RTC_INTRINSIC,1,[Define if _rtc() is not found.])])

  AC_MSG_RESULT($rtc_ok)

elif test "$OS" = "bgp"; then

  CC=powerpc-bgp-linux-gcc 

  F77=powerpc-bgp-linux-gfortran

  walltimer=cycle

  virtualtimer=perfctr

  tls=no

  ffsll=yes

  cross_compiling=yes

elif test "$OS" = "bgq"; then

  AC_ARG_WITH(bgpm_installdir,

              [  --with-bgpm_installdir=<path> Specify the installation path of BGPM],

              [BGPM_INSTALL_DIR=$withval

              CFLAGS="$CFLAGS -I$withval"],

              [AC_MSG_ERROR([BGQ CPU component requires installation path of BGPM (see --with-bgpm_installdir)])])

  bitmode=64

  tls=no

elif test "$OS" = "linux"; then

  if test "$arch" = "ppc64" -o "$arch" = "x86_64"; then

    if test "$bitmode" = "64" -a "$libdir" = '${exec_prefix}/lib'; then

      libdir='${exec_prefix}/lib64'

    fi

  fi

elif test "$OS" = "solaris"; then

  AC_CHECK_TYPE([hrtime_t],

                [AC_DEFINE(HAVE_HRTIME_T, 1, [Define if hrtime_t is defined in <sys/time.h>])],[],

                [#if HAVE_SYS_TIME_H

                 #include <sys/time.h>

                 #endif])

  if test "x$AR" = "x"; then

    AR=/usr/ccs/bin/ar

  fi

fi

if test "x$AR" = "x"; then

  AR=ar

fi

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

  AC_MSG_CHECKING(for native compiler for header generation)

  AC_ARG_WITH(nativecc,

	         [  --with-nativecc=<path>		Specify native C compiler for header generation ],

	         [nativecc=$withval],

	         [nativecc=gcc])

  AC_MSG_RESULT($nativecc)

fi

AC_ARG_WITH(tests,

        	[  --with-tests=<ctests,ftests,"ctests ftests">		Specify which tests to run on install ],

        	[tests=$withval],

        	[tests="ctests ftests"]) 

AC_MSG_CHECKING(for debug build)

AC_ARG_WITH(debug,

            [  --with-debug=<yes,memory,no>		Build a debug version, debug version plus memory tracker or none ],

            [debug=$withval])

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

  if test "$CC_COMMON_NAME" = "gcc"; then

    CFLAGS="$CFLAGS -g3"

  fi

  OPTFLAGS="-O0"

  PAPICFLAGS+=" -DDEBUG -DPAPI_NO_MEMORY_MANAGEMENT" 

elif test "$debug" = "memory"; then

  if test "$CC_COMMON_NAME" = "gcc"; then

    CFLAGS="$CFLAGS -g3"

  fi

  OPTFLAGS="-O0"

  PAPICFLAGS+=" -DDEBUG" 

else

  PAPICFLAGS+="-DPAPI_NO_MEMORY_MANAGEMENT" 			

fi

AC_MSG_RESULT($debug)

if test "$CC_COMMON_NAME" = "gcc"; then

  gcc_version=`gcc -v 2>&1 | tail -n 1 | awk '{printf $3}'`

  major=`echo $gcc_version | sed 's/\([[^.]][[^.]]*\).*/\1/'`

  minor=`echo $gcc_version | sed 's/[[^.]][[^.]]*.\([[^.]][[^.]]*\).*/\1/'`

  if (test "$major" -ge 4 || test "$major" = 3 -a "$minor" -ge 4); then

    CFLAGS+=" -Wextra"

  else

    CFLAGS+=" -W"

  fi

# -Wextra => -Woverride-init on gcc >= 4.2

# This issues a warning (error under -Werror) for some libpfm4 code. 

	AC_MSG_CHECKING( for -Wno-override-init)

		oldcflags="$CFLAGS"

		CFLAGS+=" -Wall -Wextra -Werror -Wno-override-init"

		AC_COMPILE_IFELSE([AC_LANG_SOURCE( 

						[ struct A { int x; int y; };

						int main(void) { struct A a = {.x = 0, .y = 0, .y = 5 }; return a.x; }

						])], 

						[HAVE_NO_OVERRIDE_INIT=1],

						[HAVE_NO_OVERRIDE_INIT=0] )

		CFLAGS="$oldcflags"

AC_MSG_RESULT($HAVE_NO_OVERRIDE_INIT)

fi

AC_MSG_CHECKING(for CPU type)

AC_ARG_WITH(CPU,

            [  --with-CPU=<cpu>		Specify CPU type],

            [CPU=$withval

             case "$CPU" in

               core|core2|i7|atom|p4|p3|opteron|athlon)

                   MISCSRCS="$MISCSRCS x86_cpuid_info.c" 

             esac],

	        [case "$OS" in

               aix)

                 CPU="`/usr/sbin/lsattr -E -l proc0 | grep type | cut -d '_' -f 2 | cut -d ' ' -f 1 | tr '[A-Z]' '[a-z]'`"

                 if test "$CPU" = ""; then

                   CPU="`/usr/sbin/lsattr -E -l proc1 | grep type | cut -d '_' -f 2 | cut -d ' ' -f 1 | tr '[A-Z]' '[a-z]'`"

                 fi ;;

	       freebsd)

                   family=`uname -m`

		   if test "$family" = "amd64"; then

                      MISCSRCS="$MISCSRCS x86_cpuid_info.c" 

		   elif test "$family" = "i386"; then

                      MISCSRCS="$MISCSRCS x86_cpuid_info.c" 

		   fi ;;

	       darwin)

                   family=`uname -m`

                   MISCSRCS="$MISCSRCS x86_cpuid_info.c" 

		   ;;

               linux)

                   family=`uname -m`

		   if test "$family" = "x86_64"; then

                      MISCSRCS="$MISCSRCS x86_cpuid_info.c" 

		      CPU="x86"

		   elif test "$family" = "i686"; then

                      MISCSRCS="$MISCSRCS x86_cpuid_info.c" 

		      CPU="x86"

                   elif test "$family" = "ppc64"; then

                     CPU_info="`cat /proc/cpuinfo | grep cpu | cut -d: -f2 | cut -d' ' -f2 | sed '2,$d'`"

                     case "$CPU_info" in

                       PPC970*) CPU="PPC970";;

                       POWER5)  CPU="POWER5";;

                       POWER5+) CPU="POWER5+";;

                       POWER6)  CPU="POWER6";;

                       POWER7)  CPU="POWER7";;

                     esac

	           fi ;;

               solaris)

                 AC_CHECK_HEADER([libcpc.h],

                                 [CFLAGS="$CFLAGS -lcpc"

                                  AC_TRY_RUN([#include <stdlib.h>

                                              #include <libcpc.h> 

                                              int main() {

                                              // Check for libcpc 2

                                              if(CPC_VER_CURRENT == 2) 

                                                exit(0);

                                              exit(1);

                                              } ], 

                                             [cpc_version=2], 

                                             [cpc_version=0])],

                                 [AC_MSG_ERROR([libcpc is needed for running PAPI on Solaris]) ])

                 processor=`uname -p`

                 machinetype=`uname -m`

                 if test "$processor" = "sparc"; then

                   if test "$machinetype" = "sun4u"; then

                     CPU=ultra

                     AC_CHECK_LIB([cpc], [cpc_take_sample], [], 

                                  [AC_MSG_ERROR([libcpc.a is needed on Solaris, install SUNWcpc]) ])

                   elif test "$machinetype" = "sun4v"; then

                     CPU=niagara2

                     if test "$cpc_version" != "2"; then

                       AC_MSG_ERROR([libcpc2 needed for Niagara 2])

                     fi

                   else

                     AC_MSG_ERROR([$machinetype not supported])

                   fi

                 else

                   AC_MSG_ERROR([Only SPARC processors are supported on Solaris])

                 fi ;;

               bgp)

	             CPU=bgp ;;

			   bgq)

	             CPU=bgq ;;

               esac ])

AC_MSG_RESULT($CPU)

AC_DEFINE_UNQUOTED(CPU,$CPU,[cpu type])

# First set pthread-mutexes based on arch                                       

case $arch in

  aarch64|arm*)

    pthread_mutexes=yes

    CFLAGS="$CFLAGS -DUSE_PTHREAD_MUTEXES"

    echo "forcing use of pthread mutexes... " >&6

  ;;

esac

AC_ARG_WITH(pthread-mutexes,

              [  --with-pthread-mutexes		Specify use of pthread mutexes rather than custom PAPI locks],

              [pthread_mutexes=yes

	      CFLAGS="$CFLAGS -DUSE_PTHREAD_MUTEXES"

	      ])

  AC_ARG_WITH(ffsll,

	          [  --with-ffsll		Specify use of the ffsll() function ],

	          [ffsll=$withval],

	          [if test "$cross_compiling" = "yes" ; then

                 AC_MSG_ERROR([ffsll must be specified for cross compile])

		       fi

               didcheck=1

               AC_CHECK_FUNC(ffsll,[ffsll=yes],[ffsll=no]) ])

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

                 AC_DEFINE(HAVE_FFSLL, 1, This platform has the ffsll() function)

               fi

if test "$didcheck" != "1"; then

  AC_MSG_CHECKING(for ffsll)

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

    AC_DEFINE(HAVE_FFSLL, 1, This platform has the ffsll() function)

  fi

  AC_MSG_RESULT($ffsll)

fi

AC_MSG_CHECKING(for working gettid)

AC_LINK_IFELSE([AC_LANG_SOURCE([#include <sys/types.h>

                main() { pid_t a = gettid(); }])],

               [AC_MSG_RESULT(yes)

                AC_DEFINE(HAVE_GETTID, 1, [Full gettid function])],

               [AC_MSG_RESULT(no)

                AC_MSG_CHECKING(for working syscall(SYS_gettid))

                AC_LINK_IFELSE([AC_LANG_SOURCE([#include <sys/types.h>

                                #include <sys/syscall.h>

                                main() { pid_t a = syscall(SYS_gettid); }])],

                               [AC_MSG_RESULT(yes)

                                AC_DEFINE(HAVE_SYSCALL_GETTID, 1, [gettid syscall function])],

                               [AC_MSG_RESULT(no)]) ])

AC_ARG_WITH(walltimer,

            [  --with-walltimer=<gettimeofday,mmtimer,clock_realtime_hr,clock_realtime,cycle>		Specify realtime timer ],

            [walltimer=$withval],

            [if test "$cross_compiling" = "yes" ; then

               AC_MSG_ERROR([walltimer must be specified for cross compile])

             fi

             AC_MSG_CHECKING(for working MMTIMER)

             AC_TRY_RUN([#include <unistd.h>

                         #include <fcntl.h>

                         #include <errno.h>

                         #include <stdlib.h>

                         #include <sys/ioctl.h>

                         #include <linux/mmtimer.h>

                         #ifndef MMTIMER_FULLNAME

                         #define MMTIMER_FULLNAME "/dev/mmtimer"

                         #endif

                         int main() {

                           int offset;

                           int fd;

                           if((fd = open(MMTIMER_FULLNAME, O_RDONLY)) == -1) 

                             exit(1);

                           if ((offset = ioctl(fd, MMTIMER_GETOFFSET, 0)) < 0) 

                             exit(1);

                           close(fd);

                           exit(0);

                         } ],

                        [walltimer="mmtimer"

	                     AC_MSG_RESULT(yes)],

                        [AC_MSG_RESULT(no)

                         AC_MSG_CHECKING(for working CLOCK_REALTIME_HR POSIX 1b timer)

                         AC_TRY_RUN([#include <unistd.h>

                                     #include <stdlib.h>

                                     #include <stdio.h>

                                     #include <time.h>

                                     #include <syscall.h>

                                     main() {

                                       struct timespec t1, t2;

                                       double seconds;

                                       if (syscall(__NR_clock_gettime,CLOCK_REALTIME_HR,&t1) == -1) exit(1);

                                         sleep(1);

                                       if (syscall(__NR_clock_gettime,CLOCK_REALTIME_HR,&t2) == -1) exit(1);

                                         seconds = ((double)t2.tv_sec + (double)t2.tv_nsec/1000000000.0) - ((double)t1.tv_sec + (double)t1.tv_nsec/1000000000.0);

                                       if (seconds > 1.0)

                                         exit(0);

                                       else

                                         exit(1);

                                     } ],

                                    [walltimer="clock_realtime_hr"

	                                 AC_MSG_RESULT(yes)],

                                    [AC_MSG_RESULT(no)

                                     AC_MSG_CHECKING(for working CLOCK_REALTIME POSIX 1b timer)

                                     AC_TRY_RUN([#include <unistd.h>

                                                 #include <stdlib.h>

                                                 #include <stdio.h>

                                                 #include <time.h>

                                                 #include <syscall.h>

                                                 main() {

                                                   struct timespec t1, t2;

                                                   double seconds;

                                                   if (syscall(__NR_clock_gettime,CLOCK_REALTIME,&t1) == -1) exit(1);

                                                     sleep(1);

                                                   if (syscall(__NR_clock_gettime,CLOCK_REALTIME,&t2) == -1) exit(1);

                                                     seconds = ((double)t2.tv_sec + (double)t2.tv_nsec/1000000000.0) - ((double)t1.tv_sec + (double)t1.tv_nsec/1000000000.0);

                                                   if (seconds > 1.0)

                                                     exit(0);

                                                   else

                                                     exit(1);

                                                 } ],

                                                [walltimer="clock_realtime"

	                                             AC_MSG_RESULT(yes)	],

                                                [walltimer="cycle"

	                                             AC_MSG_RESULT(no)]) ]) ])  ])

AC_MSG_CHECKING(for which real time clock to use)

if test "$walltimer" = "gettimeofday"; then

  AC_DEFINE(HAVE_GETTIMEOFDAY, 1, [Normal gettimeofday timer])

elif test "$walltimer" = "mmtimer"; then

  AC_DEFINE(HAVE_MMTIMER, 1, [Altix memory mapped global cycle counter])

  altix="-DALTIX"

elif test "$walltimer" = "clock_realtime_hr"; then

  AC_DEFINE(HAVE_CLOCK_GETTIME, 1, [POSIX 1b clock])

  AC_DEFINE(HAVE_CLOCK_GETTIME_REALTIME_HR, 1, [POSIX 1b realtime HR clock])

elif test "$walltimer" = "clock_realtime"; then

  AC_DEFINE(HAVE_CLOCK_GETTIME, 1, [POSIX 1b clock])

  AC_DEFINE(HAVE_CLOCK_GETTIME_REALTIME, 1, [POSIX 1b realtime clock])

elif test "$walltimer" = "cycle"; then

  AC_DEFINE(HAVE_CYCLE, 1, [Native access to a hardware cycle counter])

else

  AC_MSG_ERROR([Unknown value for walltimer])

fi

AC_MSG_RESULT($walltimer)

SAVED_LIBS=$LIBS

SAVED_LDFLAGS=$LDFLAGS

SAVED_CFLAGS=$CFLAGS

LIBS=""

LDFLAGS=""

CFLAGS="-pthread"

AC_ARG_WITH(tls,

              [  --with-tls=<keyword>		This platform supports thread local storage with a keyword ],

              [tls=$withval],

              [if test "$cross_compiling" = "yes" ; then

                 AC_MSG_ERROR([tls must be specified for cross compile])

               fi

               AC_MSG_CHECKING(for working __thread)

               AC_TRY_RUN([#include <pthread.h>

                           #include <unistd.h>

                           extern __thread int i;

                           static int res1, res2;

                           void thread_main (void *arg) {

                             i = (int)arg;

                             sleep (1);

                             if ((int)arg == 1)

		                       res1 = (i == (int)arg);

                             else

		                       res2 = (i == (int)arg);

                           }

	                       __thread int i;

                           int main () {

                             pthread_t t1, t2;

                             i = 5;

                             pthread_create (&t1, NULL, thread_main, (void *)1);

                             pthread_create (&t2, NULL, thread_main, (void *)2);

                             pthread_join (t1, NULL);

                             pthread_join (t2, NULL);

                             return !(res1 + res2 == 2);

                           } ], 

                          [AC_MSG_RESULT(yes)

	                       tls="__thread"], 

                          [AC_MSG_RESULT(no)

                           tls="no" ])

               if test "$OS" = "linux"; then

                 if test "x$tls" = "x__thread"; then

                   # On some linux distributions, TLS works in executables, but linking against

                   # a shared library containing TLS fails with: undefined reference to `__tls_get_addr'

                   rm -f conftest.c conftest.so conftest

                   echo "static __thread int foo; void main () { foo = 5; }" > conftest.c

                   gcc -fPIC --shared -o conftest.so conftest.c > /dev/null 2>&1

                   gcc -o conftest conftest.so > /dev/null 2>&1

                     if test ! -f conftest; then

                       AC_MSG_WARN([Disabling usage of __thread.]);

                       tls="no"

                     fi

                   rm -f conftest.c conftest.so conftest

                 fi

               fi])

AC_MSG_CHECKING(for high performance thread local storage)

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

  NOTLS="-DNO_TLS"

elif test "x$tls" != "x"; then

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

    tls="__thread"

  fi

  NOTLS="-DUSE_COMPILER_TLS"

  AC_DEFINE_UNQUOTED(HAVE_THREAD_LOCAL_STORAGE,$tls,[Keyword for per-thread variables])

fi

AC_MSG_RESULT($tls)

AC_ARG_WITH(virtualtimer,

              [  --with-virtualtimer=<clock_thread_cputime_id,times,proc,getrusage,perfctr>		Specify per-thread virtual timer ],

              [virtualtimer=$withval],

              [if test "$cross_compiling" = "yes" ; then

                 AC_MSG_ERROR([virtualtimer must be specified for cross compile])

               fi

               AC_MSG_CHECKING(for working CLOCK_THREAD_CPUTIME_ID POSIX 1b timer)

               AC_TRY_RUN([#include <pthread.h>

                           #include <sys/signal.h>

                           #include <sys/times.h>

                           #include <assert.h>

                           #include <stdio.h>

                           #include <sys/types.h>

                           #include <unistd.h>

                           #include <sys/unistd.h>

                           #include <syscall.h>

                           #include <stdlib.h>

                           #if !defined( SYS_gettid )

                           #define SYS_gettid 1105

                           #endif

                           struct timespec threadone = { 0, 0 };

                           struct timespec threadtwo = { 0, 0 };

                           pthread_t threadOne, threadTwo;

                           volatile int done = 0;

                           int gettid() {

                             return syscall( SYS_gettid );

                           }

                           void *doThreadOne( void * v ) {

                             while (!done)

	                           sleep(1);

                             if (syscall(__NR_clock_gettime,CLOCK_THREAD_CPUTIME_ID,&threadone) == -1) {

                               perror("clock_gettime(CLOCK_THREAD_CPUTIME_ID)");

                               exit(1);

                             }

                             return 0;

                           } 

                           void *doThreadTwo( void * v ) {

                             long i, j = 0xdeadbeef;     

                             for( i = 0; i < 0xFFFFFFF; ++i ) { j = j ^ i; }

                             if (syscall(__NR_clock_gettime,CLOCK_THREAD_CPUTIME_ID,&threadtwo) == -1) {

                               perror("clock_gettime(CLOCK_THREAD_CPUTIME_ID)");

                               exit(1);

                             }        

                             done = 1;

	                         return j;

                           } 

                           int main( int argc, char ** argv ) {

                             int status = pthread_create( & threadOne, NULL, doThreadOne, NULL );

                             assert( status == 0 );

                             status = pthread_create( & threadTwo, NULL, doThreadTwo, NULL );

                             assert( status == 0 );  

                             status = pthread_join( threadTwo, NULL );

                             assert( status == 0 );

                             status = pthread_join( threadOne, NULL );

                             assert( status == 0 );

                             if ((threadone.tv_sec != threadtwo.tv_sec) || (threadone.tv_nsec != threadtwo.tv_nsec))

                               exit(0);

                             else {	

                               fprintf(stderr,"T1 %ld %ld T2 %ld %ld\n",threadone.tv_sec,threadone.tv_nsec,threadtwo.tv_sec,threadtwo.tv_nsec);

	                           exit(1); 

                             }

                           } ], 

                          [AC_MSG_RESULT(yes)

                           virtualtimer="clock_thread_cputime_id"], 

                          [AC_MSG_RESULT(no)

                           # *** Checks for working per thread timer***

                           AC_MSG_CHECKING(for working per-thread times() timer)

                           AC_TRY_RUN([#include <pthread.h>

                                       #include <sys/signal.h>

                                       #include <sys/times.h>

                                       #include <assert.h>

                                       #include <stdio.h>

                                       #include <sys/types.h>

                                       #include <unistd.h>

                                       #include <sys/unistd.h>

                                       #include <syscall.h>

                                       #include <stdlib.h>

                                       #if !defined( SYS_gettid )

                                       #define SYS_gettid 1105

                                       #endif

                                       long threadone = 0, threadtwo = 0;

                                       pthread_t threadOne, threadTwo;

                                       volatile int done = 0;

                                       int gettid() {

                                         return syscall( SYS_gettid );

                                       } 

                                       int doThreadOne( void * v ) {

                                         struct tms tm;

                                         int status;

                                         while (!done)

	                                       sleep(1);

                                         status = times( & tm );

                                         assert( status != -1 );

                                         threadone = tm.tms_utime;

                                         return 0;

                                       }   

                                       int doThreadTwo( void * v ) {

                                         struct tms tm;

                                         long i, j = 0xdeadbeef;

                                         int status;

                                         for( i = 0; i < 0xFFFFFFF; ++i ) { j = j ^ i; }

                                         status = times( & tm );

                                         assert( status != -1 );

                                         threadtwo = tm.tms_utime;

                                         done = 1;

	                                     return j;

                                       } 

                                       int main( int argc, char ** argv ) {

                                         int status = pthread_create( & threadOne, NULL, doThreadOne, NULL );

                                         assert( status == 0 );

                                         status = pthread_create( & threadTwo, NULL, doThreadTwo, NULL );

                                         assert( status == 0 );  

                                         status = pthread_join( threadTwo, NULL );

                                         assert( status == 0 );

                                         status = pthread_join( threadOne, NULL );

                                         assert( status == 0 );

	                                     return (threadone == threadtwo);

                                       } ],

                                      [AC_MSG_RESULT(yes)

	                                   virtualtimer="times"],

                                      [AC_MSG_RESULT(no)

	                                   virtualtimer="default"]) ]) ])

LDFLAGS=$SAVED_LDFLAGS

CFLAGS=$SAVED_CFLAGS

LIBS=$SAVED_LIBS

AC_MSG_CHECKING(for which virtual timer to use)

case "$virtualtimer" in

  times)

    AC_DEFINE(HAVE_PER_THREAD_TIMES, 1, [Working per thread timer]) ;;

  getrusage)

    AC_DEFINE(HAVE_PER_THREAD_GETRUSAGE, 1, [Working per thread getrusage]) ;;

  clock_thread_cputime_id)

    AC_DEFINE(HAVE_CLOCK_GETTIME_THREAD, CLOCK_THREAD_CPUTIME_ID, [POSIX 1b per-thread clock]) ;;

  proc|default|perfctr)

    AC_DEFINE(USE_PROC_PTTIMER, 1, [Use /proc for per-thread times])

    AC_DEFINE(USE_PERFCTR_PTTIMER, 1, [Use the perfctr virtual TSC for per-thread times]) ;;

esac

AC_MSG_RESULT($virtualtimer)

if test "$OS" = "aix"; then

  AC_ARG_WITH(pmapi,

              [  --with-pmapi=<path>		Specify path of pmapi on aix system ],

              [PMAPI=$withval],

              [PMAPI="/usr/pmapi"])

  LIBS="-L$PMAPI/lib -lpmapi"

  CPPFLAGS="$CPPFLAGS -I$PMAPI/include"

  AC_CHECK_LIB([pmapi], [pm_initialize], 

               [PMINIT="-DPM_INITIALIZE"], 

               [AC_CHECK_LIB([pmapi], [pm_init], 

                             [PMINIT="-DPM_INIT"], 

                             [AC_MSG_ERROR([libpmapi.a not found, rerun configure with different flags]) ]) ])

fi

AC_MSG_CHECKING(for static user preset events)

AC_ARG_WITH(static_user_events,

		  [ --with-static-user-events             Build with a static user events file.],

		  [STATIC_USER_EVENTS=$withval],

		  [STATIC_USER_EVENTS=no])

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

	PAPICFLAGS+=" -DSTATIC_USER_EVENTS"

fi

AC_MSG_RESULT($STATIC_USER_EVENTS)

AC_MSG_CHECKING(for static PAPI preset events)

AC_ARG_WITH(static_papi_events,

		  [ --with-static-papi-events             Build with a static papi events file.],

		  [STATIC_PAPI_EVENTS=$withval],

		  [STATIC_PAPI_EVENTS=yes])

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

	PAPICFLAGS+=" -DSTATIC_PAPI_EVENTS_TABLE"

fi

AC_MSG_RESULT($STATIC_PAPI_EVENTS)

AC_MSG_CHECKING(for whether to build static library)

AC_ARG_WITH(static_lib,

            [  --with-static-lib=<yes,no>		Build a static library],

            [static_lib=$withval],

            [static_lib=yes])

AC_MSG_RESULT($static_lib)

AC_MSG_CHECKING(for whether to build shared library)

AC_ARG_WITH(shared_lib,

            [  --with-shared-lib=<yes,no>		Build a shared library],

            [shared_lib=$withval],

            [shared_lib=yes])

AC_MSG_RESULT($shared_lib)

if test "$shared_lib" = "no" -a "$static_lib" = "no"; then

  AC_MSG_ERROR(Both shared and static libs are disabled)

fi

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

  papiLIBS="shared"

fi

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

  papiLIBS="$papiLIBS static"

fi

AC_MSG_CHECKING(for static compile of tests and utilities)

AC_ARG_WITH(static_tools,

            [  --with-static-tools		Specify static compile of tests and utilities],

            [STATIC="-static"

	    AC_MSG_RESULT(yes)],

	    [AC_MSG_RESULT(no)])

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

   AC_MSG_ERROR(Building tests and utilities static but no static papi library to be built)

fi

AC_MSG_CHECKING(for linking with papi shared library of tests and utilities)

AC_ARG_WITH(shlib_tools,

	        [  --with-shlib-tools		Specify linking with papi library of tests and utilities],

 	        [shlib_tools=yes

		AC_MSG_RESULT(yes)],

		[shlib_tools=no

		AC_MSG_RESULT(no)])

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

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

      AC_MSG_ERROR(Building static but specified shared linking for tests and utilities)

   fi

   if test "$STATIC" = "-static"; then

      AC_MSG_ERROR([Building shared but specified static linking])

   fi

   LINKLIB='$(SHLIB)'

elif test "$shlib_tools" = "no"; then

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

      AC_MSG_ERROR([Building shared but specified static linking for tests and utilities])

   fi

   LINKLIB='$(LIBRARY)'	

fi

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

#          perfctr

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

perfctr=0

force_perfctr=no

AC_ARG_WITH(perfctr,

            [  --with-perfctr		Specify perfctr as the performance interface ],

	    force_perfctr=yes

            [user_specified_interface=perfctr

	     if test "$arch" != "ppc64"; then

	     perfctr=6

	     else

	     perfctr=7

	     fi],

            [perfctr=0])

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

  AC_CHECK_FILE(/sys/class/perfctr,[perfctr=7],[AC_CHECK_FILE(/dev/perfctr,[perfctr=6])])

fi 

if test "$perfctr" != 0; then 

  pfm_incdir="libpfm-3.y/include/"

  AC_MSG_CHECKING(for perfctr version)

  if test "$perfctr" = 7 -a "$arch" != "ppc64"; then

    AC_MSG_ERROR([Perfctr 2.7.x only works on PPC64 machines. Patch kernel with 2.6.x.])

  fi

  AC_MSG_RESULT(2.$perfctr)

fi

AC_ARG_WITH(perfctr_root,

            [  --with-perfctr-root=<path>		Specify path to source tree (for use by developers only) ],

            [perfctr_root=$withval

             user_specified_interface=perfctr])

AC_ARG_WITH(perfctr_prefix,

            [  --with-perfctr-prefix=<path>		Specify prefix to installed perfctr distribution ],

            [perfctr_prefix=$withval

             user_specified_interface=perfctr])

AC_ARG_WITH(perfctr_incdir,

           [  --with-perfctr-incdir=<path>		Specify directory of perfctr header files in non-standard location ],

           [perfctr_incdir=$withval

            user_specified_interface=perfctr])

AC_ARG_WITH(perfctr_libdir,

           [  --with-perfctr-libdir=<path>		Specify directory of perfctr library in non-standard location ],

           [perfctr_libdir=$withval

            user_specified_interface=perfctr])

if test "$perfctr" != 0; then

  dotest=0

  if test "x$perfctr_root" != "x"; then

    LIBS="-L$perfctr_root/usr.lib -lperfctr"

    CPPFLAGS="$CPPFLAGS -I$perfctr_root/usr.lib -I$perfctr_root/linux/include"

    dotest=1

  elif test "x$perfctr_prefix" != "x"; then

    LIBS="-L$perfctr_prefix/lib -lperfctr"