don't test -lmpich for bgp builds
[charm.git] / src / scripts / configure.in
1
2 AC_INIT(./Makefile)
3
4 AC_CONFIG_HEADER(conv-autoconfig.h)
5
6 CHARMINC="."
7 test -r ./conv-config.sh && . ./conv-config.sh
8
9 # Decimal representation of Charm++ release line and API revision
10 # Increment the last 2 digits when making an API change
11 # Increase the first three after branching for a release
12 VERSION=60305
13 echo $VERSION > ../include/VERSION
14 AC_DEFINE_UNQUOTED([CHARM_VERSION], $VERSION, [Charm++ Release/API version number])
15
16 charmout="charmconfig.out"
17 /bin/rm -rf $charmout
18 MAKEFILE_EXT=Make.extlib
19
20 Echo() {
21         echo $* 
22         echo $* >> $charmout
23 }
24
25 # add into conv-mach-opt.sh
26 # add_flag $1 $2
27 # $2 is description
28 add_flag() {
29         key=`echo $1 | cut -d'=' -f1`
30         last=`grep "$key=" ../include/conv-mach-opt.sh 2>/dev/null | tail -1 | sed -e 's/ *#.*$//'`
31         skip=0
32         if test -n "$last" -a  "$last" = "$1" 
33         then
34           skip=1
35         fi
36         if test $skip = 0
37         then
38           cat >> ../include/conv-mach-opt.sh << EOT
39
40 $1   # Option added by configure script's $2 section
41 EOT
42         fi
43 }
44
45 # remove_flag $1
46 remove_flag() {
47      sed -e '/^'"$1"'=/d' ../include/conv-mach-opt.sh > tmp.$$
48      cp tmp.$$ ../include/conv-mach-opt.sh
49      /bin/rm -f tmp.$$
50 }
51
52
53 # enable/disable error checking
54 AC_ARG_ENABLE([error-checking],
55             [AS_HELP_STRING([--enable-error-checking],
56               [enable error checking])], ,
57             [enable_error_checking=yes])
58
59 if test "$enable_error_checking" = "no"
60 then
61   Echo "Error checking is disabled" 
62   AC_DEFINE_UNQUOTED(CMK_ERROR_CHECKING, 0, [disable error checking])
63 else
64   AC_DEFINE_UNQUOTED(CMK_ERROR_CHECKING, 1, [enable error checking])
65 fi
66
67 # enable/disable statistics collection
68 AC_ARG_ENABLE([stats],
69             [AS_HELP_STRING([--enable-stats],
70               [enable statistics collection])], ,
71             [enable_stats=yes])
72
73 if test "$enable_stats" = "no"
74 then
75   Echo "Statistics collection is disabled" 
76   AC_DEFINE_UNQUOTED(CMK_WITH_STATS, 0, [disable statistics collection])
77 else
78   AC_DEFINE_UNQUOTED(CMK_WITH_STATS, 1, [enable statistics collection])
79 fi
80
81 # check enable/disable
82 AC_ARG_ENABLE([tracing],
83             [AS_HELP_STRING([--enable-tracing],
84               [enable tracing modules])], ,
85             [enable_tracing=yes])
86
87 if test "$enable_tracing" = "no"
88 then
89   Echo "Charm tracing is disabled"
90   AC_DEFINE_UNQUOTED(CMK_TRACE_ENABLED, 0, [disable tracing])
91   add_flag CMK_TRACE_ENABLED=0
92 else
93   AC_DEFINE_UNQUOTED(CMK_TRACE_ENABLED, 1, [enable tracing])
94   add_flag CMK_TRACE_ENABLED=1
95 fi
96
97 AC_ARG_ENABLE([charmdebug],
98             [AS_HELP_STRING([--enable-charmdebug],
99               [enable charmDebug])], ,
100             [enable_charmdebug=yes])
101
102 if test "$enable_charmdebug" = "no"
103 then
104   Echo "CharmDebug is disabled" 
105   AC_DEFINE_UNQUOTED(CMK_CHARMDEBUG, 0, [disable charmdebug])
106   add_flag CMK_CHARMDEBUG=0
107 else
108   AC_DEFINE_UNQUOTED(CMK_CHARMDEBUG, 1, [enable charmdebug])
109   add_flag CMK_CHARMDEBUG=1
110 fi
111
112 AC_ARG_ENABLE([replay],
113             [AS_HELP_STRING([--enable-replay],
114               [enable record/replay])],
115             [enable_replay=$enableval],
116             [enable_replay=yes])
117
118 if test "$enable_replay" = "no"
119 then
120   Echo "Charm record/replay is disabled"
121   AC_DEFINE_UNQUOTED(CMK_REPLAYSYSTEM, 0, [disable replay])
122 fi
123
124 AC_ARG_ENABLE([ccs],
125             [AS_HELP_STRING([--enable-ccs],
126               [enable CCS])], ,
127             [enable_ccs=yes])
128
129 if test "$enable_ccs" = "no"
130 then
131   Echo "CCS is disabled" 
132   AC_DEFINE_UNQUOTED(CMK_CCS_AVAILABLE, 0, [disable ccs])
133 else
134   AC_DEFINE_UNQUOTED(CMK_CCS_AVAILABLE, 1, [enable ccs])
135 fi
136
137 AC_ARG_ENABLE([controlpoint],
138             [AS_HELP_STRING([--enable-controlpoint],
139               [enable control point])],
140             [enable_controlpoint=$enableval],
141             [enable_controlpoint=yes])
142
143 if test "$enable_controlpoint" = "yes"
144 then
145   AC_DEFINE_UNQUOTED(CMK_WITH_CONTROLPOINT, 1, [enable controlpoint])
146 else
147   Echo "Charm control point is disabled"
148   AC_DEFINE_UNQUOTED(CMK_WITH_CONTROLPOINT, 0, [disable controlpoint])
149 fi
150
151 AC_ARG_WITH([numa],
152             [AS_HELP_STRING([--with-numa],
153               [support memory affinity with NUMA])],
154             [],
155             [with_numa=no])
156
157 WITH_NUMA=no
158 if test "$with_numa" = "yes"
159 then
160   Echo "Charm NUMA support is builtin"
161   WITH_NUMA=yes
162 fi
163
164 AC_ARG_WITH([lbtime-type],
165             [AS_HELP_STRING([--with-lbtime-type=type],
166                             [load balancing timer type])],
167             [], [with_lbtime_type=double])
168
169 if test "$with_lbtime_type" = "float" -o "$with_lbtime_type" = "double"
170 then
171   Echo "Setting load balancing timer type as '$with_lbtime_type'"
172   AC_DEFINE_UNQUOTED(CMK_LBTIME_TYPE, $with_lbtime_type, [Setting load balancing timer type])
173 else
174   Echo "Invalid type specified for load balancing timer type"
175   test_finish 1
176 fi
177
178 #clean up conv-mach-opt.sh
179 sed -e '/Option added by configure/d' ../include/conv-mach-opt.sh  | sed -e '/^$/d' > conv-mach-opt.sh.clean
180 cp -f conv-mach-opt.sh.clean   ../include/conv-mach-opt.sh
181 rm -f conv-mach-opt.sh.clean
182
183
184 #
185 AC_MSG_CHECKING(machine name)
186 version=`pwd | awk -F/ '{print $(NF-1)}'`
187 base_version=`cat .vdir`
188 AC_DEFINE_UNQUOTED(CMK_MACHINE_NAME, "$version",[machine name])
189 AC_MSG_RESULT($version)
190 AC_SUBST(base_version)
191
192 t="test.cpp"
193 tc="test.c"
194
195 # test result passed in $1
196 # If the test suceeded, print $3 and set "pass"/clear "fail"
197 # If the test failed, print $2 and clear "pass"/set "fail"
198 test_result() {
199         if test $1 -eq 0
200         then
201                 AC_MSG_RESULT("$3")
202                 pass="1"
203                 fail="0"
204         else
205                 AC_MSG_RESULT("$4")
206                 pass="0"
207                 fail="1"
208 # For debugging the configure script, just "export autoconf_debug=1"
209 #  to get this verbose data on any failed tests:
210                 if test ! -z "$autoconf_debug"
211                 then
212                         echo "------- test script for $2 failed:"
213                         cat out
214                         echo "------- the test program was:"
215                         cat $t
216                         echo "-------"
217                 fi
218         fi
219 }
220
221 # Test: tries to compile C file $t (described by $1).
222 #  If successful, prints $2 and sets $pass/clears $fail
223 #  If failure, prints $3 and sets $pass/clears $fail
224 #  additional arguments to c++ compiler are passed as $4
225 test_cc() {
226         AC_MSG_CHECKING("$1")
227         echo "### $1" >> $charmout
228         cat $tc >> $charmout
229         echo $CMK_CC -I../include -I. $CMK_LIBDIR $CMK_INCDIR $OPTS_CC $OPTS_LD -c $tc -o test.o $4 >> $charmout
230         $CMK_CC -I../include -I. $CMK_LIBDIR $CMK_INCDIR $OPTS_CC $OPTS_LD -c $tc -o test.o $4 > out 2>&1
231         test_result $? "$1" "$2" "$3"
232         strictpass=$pass
233         strictfail=$fail
234         if test $pass -eq 1
235         then 
236           if cat out | grep -i "warn" > /dev/null 2>&1
237           then 
238             strictpass="0" && strictfail="1"
239           fi
240         fi
241         cat out >> $charmout
242         /bin/rm -f out
243 }
244
245 # Test: tries to compile C++ file $t (described by $1).
246 #  If successful, prints $2 and sets $pass/clears $fail
247 #  If failure, prints $3 and sets $pass/clears $fail
248 #  additional arguments to c++ compiler are passed as $4
249 test_cxx() {
250         AC_MSG_CHECKING("$1")
251         echo "### $1" >> $charmout
252         cat $t >> $charmout
253         echo $CMK_CXX -I../include -I. $CMK_LIBDIR $CMK_INCDIR $OPTS_CXX $OPTS_LD -c $t -o test.o $4 >> $charmout
254         $CMK_CXX -I../include -I. $CMK_LIBDIR $CMK_INCDIR $OPTS_CXX $OPTS_LD -c $t -o test.o $4 > out 2>&1
255         test_result $? "$1" "$2" "$3"
256         strictpass=$pass
257         strictfail=$fail
258         if test $pass -eq 1
259         then 
260           if cat out | grep -i "warn" > /dev/null 2>&1
261           then 
262             strictpass="0" && strictfail="1"
263           fi
264         fi
265         cat out >> $charmout
266         /bin/rm -f out
267 }
268
269 # Testlink: tries to compile and link a C++ file $t (described by $1).
270 #  If successful, prints $2 and sets $pass/clears $fail
271 #  If failure, prints $3 and sets $pass/clears $fail
272 #  additional arguments to c++ compiler are passed as $4
273 test_link() {
274         AC_MSG_CHECKING("$1")
275         echo "### $1" >> $charmout
276         cat $t >> $charmout
277         echo $CMK_CXX -I../include -I. $CMK_INCDIR $OPTS_CXX -c $t -o test.o $4 >> $charmout
278         $CMK_CXX -I../include -I. $CMK_INCDIR $OPTS_CXX -c $t -o test.o $4 > out 2>&1
279         if test $? -ne 0
280         then
281           test_result 1 "$1" "$2" "$3"
282         else
283           echo $CMK_LDXX -o testlink test.o $CMK_LIBDIR $OPTS_LD $CMK_SYSLIBS $4 >> $charmout
284           $CMK_LDXX -o testlink test.o $CMK_LIBDIR $OPTS_LD $CMK_SYSLIBS $4 >> out 2>&1
285           ret=$?
286           test ! -x testlink && ret=1
287           test_result $ret "$1" "$2" "$3"
288         fi
289         strictpass=$pass
290         strictfail=$fail
291         if test $pass -eq 1
292         then 
293           if cat out | grep -i "warn" > /dev/null 2>&1
294           then 
295             strictpass="0" && strictfail="1"
296           fi
297         fi
298         cat out >> $charmout
299         /bin/rm -f out
300 }
301
302 # Testlinkc: tries to compile and link a C file $t (described by $1).
303 #  If successful, prints $2 and sets $pass/clears $fail
304 #  If failure, prints $3 and sets $pass/clears $fail
305 #  additional arguments to c++ compiler are passed as $4
306 test_linkc() {
307         AC_MSG_CHECKING("$1")
308         echo "### $1" >> $charmout
309         cat $tc >> $charmout
310         echo $CMK_CC -I../include -I. $CMK_INCDIR $OPTS_CC -c $tc -o test.o $4 >> $charmout
311         $CMK_CC -I../include -I. $CMK_INCDIR $OPTS_CC -c $tc -o test.o $4 > out 2>&1
312         if test $? -ne 0
313         then
314           test_result 1 "$1" "$2" "$3"
315         else
316           echo $CMK_LD -o testlink test.o $CMK_LIBDIR $OPTS_LD $CMK_SYSLIBS $4 >> $charmout
317           $CMK_LD -o testlink test.o $CMK_LIBDIR $OPTS_LD $CMK_SYSLIBS $4 >> out 2>&1
318           test_result $? "$1" "$2" "$3"
319         fi
320         strictpass=$pass
321         strictfail=$fail
322         if test $pass -eq 1
323         then 
324           if cat out | grep -i "warn" > /dev/null 2>&1
325           then 
326             strictpass="0" && strictfail="1"
327           fi
328         fi
329         cat out >> $charmout
330         /bin/rm -f out
331 }
332
333 # test_linkso $1 $2 $3 $4, where
334 # $1: debug msg
335 # $2: yes msg
336 # $3: no msg
337 # $4: extra link option
338 test_linkso() {
339         AC_MSG_CHECKING("$1")
340         echo $1 >> $charmout
341         cat $t >> $charmout
342         echo $CMK_CXX -I../include -I. $CMK_INCDIR $OPTS_CXX $CMK_PIC -c $t -o test.o $4 >> $charmout
343         $CMK_CXX -I../include -I. $CMK_INCDIR $OPTS_CXX -c $CMK_PIC $t -o test.o $4 > out 2>&1
344         if test $? = 1
345         then
346           test_result 1 "$1" "$2" "$3"
347         else
348           echo $CMK_LD -I../include -I. $CMK_LIBDIR $OPTS_LD $CMK_LD_SHARED test.o -o testlink.$CMK_SHARED_SUF $4 >> $charmout
349           $CMK_LD -I../include -I. $CMK_LIBDIR $OPTS_LD $CMK_LD_SHARED test.o -o testlink.$CMK_SHARED_SUF $4 > out 2>&1
350           test_result $? "$1" "$2" "$3"
351         fi
352         cat out >> $charmout
353         /bin/rm -f out testlink.$CMK_SHARED_SUF
354 }
355
356 test_finish() {
357         rm -f $t $tc testlink test.o    > /dev/null 2>&1
358         /bin/rm -f out
359         test $1 -eq 1 && echo "*** Please find detailed output in charmconfig.out ***"
360         exit $1
361 }
362
363 # detect certain architectures
364 if cat /proc/cpuinfo 2>/dev/null | grep 'POWER7'  > /dev/null
365 then
366   AC_DEFINE_UNQUOTED(CMK_POWER7, 1, [whether is power7])
367 fi
368
369 # detect OS
370 OSNAME=`uname -s`
371 if test $OSNAME = "Linux"
372 then
373   AC_DEFINE_UNQUOTED(CMK_OS_IS_LINUX, 1, [OS is Linux])
374 else
375   AC_DEFINE_UNQUOTED(CMK_OS_IS_LINUX, 0, [OS is Linux])
376 fi
377
378 # test cp -p
379 AC_MSG_CHECKING("cp command as")
380 CP="cp -p"
381 touch test_file
382 if ! $CP test_file test_file.cp 2>err
383 then
384   CP="cp"
385 fi
386 rm -f test_file test_file.cp
387 AC_MSG_RESULT($CP)
388 add_flag CP=\""$CP"\" "cp command"
389  
390
391 # try to decide the version of glibc
392 get_glibc_version() {
393 t=test.c
394 cat > $t <<EOT
395 #include <stdio.h>
396 #include <gnu/libc-version.h>
397 int main (void) { puts (gnu_get_libc_version ()); return 0; }
398 EOT
399 gcc -o gver test.c
400 GLIBCVERSION=`./gver`
401 /bin/rm -f $t gver
402 }
403
404 cat > $t <<EOT
405 #include <stdio.h>
406 void foo(void) {
407         printf("Hello, world!\n");
408 }
409 EOT
410 #echo "set C++ compiler as: $CMK_CXX $OPTS_CXX $OPTS"
411 AC_MSG_CHECKING("C++ compiler as")
412 AC_MSG_RESULT("$CMK_CXX $OPTS_CXX $OPTS")
413 test_cxx "whether C++ compiler works" "ok" "no" ""
414 if test $fail -eq 1
415 then
416         echo "Cannot compile C++ programs with $CMK_CXX"
417         echo " (check your charm++ version)"
418         test_finish 1
419 fi
420
421 cat > $t <<EOT
422 #include <stdio.h>
423 int main() {
424         printf("Hello, world!\n");
425         return 0;
426 }
427 EOT
428 #echo "set C++ linker as: $CMK_LDXX $OPTS_LDXX"
429 AC_MSG_CHECKING("C++ linker as")
430 AC_MSG_RESULT("$CMK_LDXX $OPTS_LDXX")
431 test_link "whether linker works" "ok" "no" ""
432 if test $fail -eq 1
433 then
434         echo "Cannot link C++ programs with $CMK_LDXX"
435         echo " (check your charm++ version)"
436         test_finish 1
437 fi
438
439 AC_MSG_CHECKING("Native C++ compiler as")
440 AC_MSG_RESULT("$CMK_NATIVE_CXX")
441 AC_MSG_CHECKING("Sequential C++ compiler as")
442 AC_MSG_RESULT("$CMK_SEQ_CXX")
443
444 if test "$base_version" = "net-linux" 
445 then
446   test_link "whether linker accept --allow-multiple-definition" "ok" "no" "-Wl,--allow-multiple-definition"
447   if test $pass -eq 1
448   then
449         remove_flag CMK_LDXX
450         add_flag CMK_LDXX='"$CMK_LDXX -Wl,--allow-multiple-definition"' "net-linux linker"
451   fi
452 fi
453
454 if echo "$base_version" | grep "linux" > /dev/null 2> /dev/null
455 then
456   test_link "whether compiler accept -fno-stack-protector" "ok" "no" "-fno-stack-protector"
457   if test $strictpass -eq 1
458   then
459         add_flag OPTS_CC='"$OPTS_CC -fno-stack-protector"' "linux compiler"
460         add_flag OPTS_CXX='"$OPTS_CXX -fno-stack-protector"' "linux compiler"
461   fi
462 fi
463
464 # Perform the tests
465
466 AC_ARG_WITH([refnum-type],
467             [AS_HELP_STRING([--with-refnum-type=type],
468                             [size of the envelope refnum field])],
469             [], [with_refnum_type=no])
470
471 if test "$with_refnum_type" = "no" -o "$with_refnum_type" = "short"
472 then
473   Echo "Setting charm++ envelop refnum field to unsigned short"
474   AC_DEFINE_UNQUOTED(CMK_REFNUM_TYPE, unsigned short, [envelope refnum field set to UShort])
475 elif test "$with_refnum_type" = "int"
476 then
477   Echo "Setting charm++ envelop refnum field to unsigned int"
478   AC_DEFINE_UNQUOTED(CMK_REFNUM_TYPE, unsigned int, [envelope refnum field set to UInt])
479 else
480   Echo "Invalid size specified for refnum field"
481   test_finish 1
482 fi
483
484 #### Check if compiler if 64 bit ####
485 cat > $t <<EOT
486 #include <stdio.h>
487
488 int foo()
489 {
490 int x[[(int)(sizeof(void *) - 7)]]={0};
491 return x[[0]];
492 }
493 EOT
494 test_cxx "whether compiler generates code for 64-bit" "yes" "no" ""
495 AC_DEFINE_UNQUOTED(CMK_SIZET_64BIT, $strictpass, [whether size_t 64bit])
496 in64bit=$strictpass
497
498
499 #### check strings.h ####
500 cat > $t <<EOT
501 #include <strings.h>
502 int main() { 
503   char str[[8]];
504   bzero(str, 8);
505   return 0;
506 }
507 EOT
508 test_cxx "whether has strings.h " "yes" "no" ""
509 AC_DEFINE_UNQUOTED(CMK_HAS_STRINGS_H, $pass, [whether has strings.h])
510
511 #### test if has values.h ####
512 cat > $t <<EOT
513 #include <values.h>
514 int main() { 
515   double d = MAXDOUBLE;
516   return 0;
517 }
518 EOT
519 test_cxx "whether has values.h " "yes" "no" ""
520 AC_DEFINE_UNQUOTED(CMK_HAS_VALUES_H, $pass, [whether has values.h])
521
522 #### test if has stdint.h ####
523 cat > $t <<EOT
524 #include <stdint.h>
525 int main() { 
526   return 0;
527 }
528 EOT
529 test_cxx "whether has stdint.h " "yes" "no" ""
530 AC_DEFINE_UNQUOTED(CMK_HAS_STDINT_H, $pass, [whether has stdint.h])
531
532 #### test if has malloc.h ####
533 cat > $t <<EOT
534 #include <malloc.h>
535 int main() { 
536   return 0;
537 }
538 EOT
539 test_cxx "whether has malloc.h " "yes" "no" ""
540 AC_DEFINE_UNQUOTED(CMK_HAS_MALLOC_H, $pass, [whether has malloc.h])
541
542 #### test if has alloca.h ####
543 cat > $t <<EOT
544 #include <alloca.h>
545 int main() {
546   double *s=(double *)alloca(sizeof(double));
547   *s=1.0;
548   return 0;
549 }
550 EOT
551 test_cxx "whether has alloca.h " "yes" "no" ""
552 AC_DEFINE_UNQUOTED(CMK_HAS_ALLOCA_H, $pass, [whether has alloca.h])
553
554 #### test if has regex.h ####
555 cat > $t <<EOT
556 #include <regex.h>
557 int main() {
558   regex_t re;
559   regcomp(&re, ".*MOD.*", REG_EXTENDED|REG_NOSUB);
560   return 0;
561 }
562 EOT
563 test_cxx "whether has regex.h " "yes" "no" ""
564 AC_DEFINE_UNQUOTED(CMK_HAS_REGEX_H, $pass, [whether has regex.h])
565
566 #### Check bool ####
567 cat > $t <<EOT
568 #include <stdlib.h>
569 bool foo(void) { return true; }
570 EOT
571 test_cxx "whether C++ bool works" "ok" "no" ""
572 AC_DEFINE_UNQUOTED(CMK_BOOL_DEFINED, $pass, [whether C++ bool works])
573
574 #### Check long long ####
575 cat > $t <<EOT
576 #include <stdlib.h>
577 long long foo(void) { return 17; }
578 EOT
579 test_cxx "whether long long works" "ok" "no" ""
580 AC_DEFINE_UNQUOTED(CMK_LONG_LONG_DEFINED, $pass, [whether long long works])
581
582 #### Check __int64 ####
583 cat > $t <<EOT
584 #include <stdlib.h>
585 __int64 foo(void) { return 17; }
586 EOT
587 test_cxx "whether __int64 works" "ok" "no" ""
588 AC_DEFINE_UNQUOTED([CMK___int64_DEFINED], $pass, [whether __int64 works])
589
590 #### Check long double ####
591 cat > $t <<EOT
592 #include <stdlib.h>
593 long double foo(void) { return 17.0; }
594 EOT
595 test_cxx "whether long double works" "ok" "no" ""
596 AC_DEFINE_UNQUOTED(CMK_LONG_DOUBLE_DEFINED, $strictpass, [whether long double works])
597
598 #### Check ucontext and FPU pointer ####
599 cat > $t <<EOT
600 #include <ucontext.h>
601 struct _libc_fpstate   fpstate;
602 fpregset_t *fp;
603 EOT
604 test_cxx "whether ucontext has FPU pointer" "yes" "no" ""
605 AC_DEFINE_UNQUOTED(CMK_CONTEXT_FPU_POINTER, $pass, [whether ucontext has pointer])
606
607 if test $pass -eq 1
608 then
609 cat > $t <<EOT
610 #include <ucontext.h>
611
612 int main()
613 {
614   ucontext_t context;
615   context.uc_mcontext.uc_regs = 0;
616 }
617 EOT
618 test_cxx "whether ucontext uses uc_regs" "yes" "no" ""
619 AC_DEFINE_UNQUOTED(CMK_CONTEXT_FPU_POINTER_UCREGS, $pass, [whether ucontext uses uc_regs union])
620 fi
621
622 cat > $t <<EOT
623 #include <ucontext.h>
624 vrregset_t *v_regs;
625 ucontext_t  uc;
626
627 void foo()
628 {
629   vrregset_t *ptr = uc.uc_mcontext.v_regs;
630 }
631 EOT
632 test_cxx "whether ucontext has pointer (v_regs) of vector type" "yes" "no" ""
633 AC_DEFINE_UNQUOTED(CMK_CONTEXT_V_REGS, $pass, [whether ucontext has pointer (v_regs) of vector type])
634
635 ###################### C++ Compiler Features #####################
636
637 #### check C inline ####
638 cat > $tc <<EOT
639 inline static int foo()
640 {
641   return 1;
642 }
643 EOT
644 test_cc "whether inline works in C" "yes" "no" ""
645 AC_DEFINE_UNQUOTED(CMK_C_INLINE, $strictpass, [whether C inline works in C])
646
647 #### check explicit ####
648 cat > $t <<EOT
649 #include <stdlib.h>
650 class er {
651  protected:
652    explicit er(unsigned int inType) {};
653 };
654 EOT
655 test_cxx "whether C++ class explicit keyword works" "ok" "no" ""
656 AC_DEFINE_UNQUOTED(CMK_EXPLICIT, $pass, [whether C++ class explicit keyword works])
657
658 #### check if signed char is same as char ####
659 cat > $t <<EOT
660 #include <stdlib.h>
661 class er {
662  protected:
663    void operator()(char &v,const char *desc=NULL) {};
664    void operator()(signed char &v,const char *desc=NULL) {};
665 };
666 EOT
667 test_cxx "whether C++ signed char and char differ" "yes" "no" ""
668 AC_DEFINE_UNQUOTED(CMK_SIGNEDCHAR_DIFF_CHAR, $pass, [whether C++ signed char and char differ])
669
670 #### check if C++ casts work ####
671 cat > $t <<EOT
672 int foo(float *t) {return *reinterpret_cast<int *>(t);}
673 EOT
674 test_cxx "whether C++ *_casts<> work" "ok" "no" ""
675 AC_DEFINE_UNQUOTED(CMK_CPP_CAST_LEGAL, $pass, [C++ *_casts<> work])
676 AC_DEFINE_UNQUOTED(CMK_CPP_CAST_ILLEGAL, $fail, [C++ *_casts<> does not work])
677
678
679 ### check if varsize array on stack ####
680 cat > $t <<EOT
681 #include <stdio.h>
682 void foo()
683 {
684   int size=10;
685   char arr[size];
686 }
687
688 EOT
689 test_cxx "whether C++ allows declaration of varsize array" "yes" "no" ""
690 AC_DEFINE_UNQUOTED(CMK_DECLARE_VARSIZE_ARRAY, $pass, [whether C++ allows declaration of variable sized array])
691
692 #### check if namespaces can be defined #####
693 cat > $t <<EOT
694 namespace foo {
695         int x;
696 }
697 EOT
698 test_cxx "whether namespaces work" "ok" "no" ""
699 AC_DEFINE_UNQUOTED(CMK_NAMESPACES_BROKEN, $fail, [whether namespaces work])
700
701
702 #### check if typeinfo exists and works #####
703 cat > $t <<EOT
704 #include <typeinfo>
705 const char *foo(void) {
706         int x;
707         return typeid(x).name();
708 }
709 EOT
710 test_cxx "whether typeinfo/typeid works" "ok" "no" ""
711 AC_DEFINE_UNQUOTED(CMK_HAS_TYPEINFO, $pass, [whether typeinfo/typeid works])
712
713 #### check if iterator_traits is defined #####
714 cat > $t <<EOT
715 #include <iterator>
716
717 template <typename T> // T models Input Iterator
718 typename std::iterator_traits<T>::value_type accumulate(T first, T last)
719 {
720       typename std::iterator_traits<T>::value_type result = 0;
721       while(first != last)
722             result += *first++;
723       return result;
724 }
725 EOT
726 test_cxx "whether std::iterator_traits is defined" "ok" "no" ""
727 AC_DEFINE_UNQUOTED(CMK_HAS_ITERATOR_TRAITS, $pass, [whether iterator_traits works])
728
729 #### check if std::distance is defined #####
730 cat > $t <<EOT
731 #include <vector>
732 #include <iterator>
733
734 int foo()
735 {
736   std::vector<int> tree;
737   return std::distance(tree.begin(), tree.end());
738 }
739 EOT
740 test_cxx "whether std::distance is defined" "ok" "no" ""
741 AC_DEFINE_UNQUOTED(CMK_HAS_STD_DISTANCE, $pass, [whether std::distance works])
742
743 #### check if std::inserter is defined #####
744 cat > $t <<EOT
745 #include <list>
746 #include <iterator>
747
748 void foo()
749 {
750   using namespace std;
751   list<int> L;
752   inserter ( L, L.end ( ) ) = 500;
753 }
754 EOT
755 test_cxx "whether std::inserter is defined" "ok" "no" ""
756 AC_DEFINE_UNQUOTED(CMK_HAS_STD_INSERTER, $pass, [whether std::inserter works])
757
758
759 #### test if we can have multiple delete like this ####
760 cat > $t <<EOT
761 class foo {
762 public:
763   void operator delete(void*p){};
764   void operator delete(void*p,int*){};
765 };
766 EOT
767 test_cxx "whether operator delete can be overloaded in same class" "ok" "no" ""
768 AC_DEFINE_UNQUOTED(CMK_MULTIPLE_DELETE, $strictpass, [whether operator delete can be overloaded in same class])
769
770 #### test if offsetof exists ####
771 cat > $t <<EOT
772 #include <stddef.h>
773
774 struct FooType {
775         int f1;
776         int f2;
777         double f3;
778 };
779
780 void foo()
781 {
782   int off = offsetof(FooType, f2);
783 }
784 EOT
785 test_cxx "whether offsetof is defined" "yes" "no" ""
786 AC_DEFINE_UNQUOTED(CMK_HAS_OFFSETOF, $pass, [whether offsetof exists])
787
788 #### test if we can use gcc x86 assembly like this ####
789 cat > $t <<EOT
790 double foo(void)
791 {
792   unsigned long long int v;
793   int *lo=0+(int *)&v;
794   int *hi=1+(int *)&v;
795   __asm__ __volatile__(
796       "rdtsc; movl %%edx,%0; movl %%eax,%1"
797       : /* output  */ "=m" (*hi), "=m" (*lo)
798       : /* input */
799       : /* trashes */ "%edx", "%eax"
800   );
801   return v;
802 }
803 EOT
804 test_cxx "whether GCC x86 assembly works" "yes" "no" ""
805 AC_DEFINE_UNQUOTED(CMK_GCC_X86_ASM, $strictpass, [Allows gcc x86 assembly.])
806
807 #### test if we can use gcc x86 assembly like this ####
808 if test $strictpass = 1
809 then
810 cat > $t <<EOT
811 int foo(void)
812 {
813   int x;
814   asm("lock incl %0" :: "m" (x));
815   asm("lock decl %0" :: "m" (x));
816   return x;
817 }
818 EOT
819 test_cxx "whether GCC x86 assembly for atomic increment works" "yes" "no" ""
820 AC_DEFINE_UNQUOTED(CMK_GCC_X86_ASM_ATOMICINCREMENT, $strictpass, [Allows gcc x86 assembly for atomic increment.])
821 fi
822
823 #### test if we can use gcc IA64 assembly like this ####
824 cat > $t <<EOT
825 double foo(void)
826 {
827         unsigned long long int x;
828         __asm__ __volatile__("mov %0=ar.itc" : "=r"(x) :: "memory");
829         return x;
830 }
831 EOT
832 test_cxx "whether GCC IA64 assembly works" "yes" "no" ""
833 AC_DEFINE_UNQUOTED(CMK_GCC_IA64_ASM, $strictpass, [Allows gcc IA64 assembly.])
834
835
836 #### test if we can use PPC assembly like this ####
837 cat > $t <<EOT
838 double foo(void)
839 {
840         unsigned long long int x;
841         asm volatile("eieio" ::: "memory");
842         return x;
843 }
844 EOT
845 test_cxx "whether PPC assembly works" "yes" "no" ""
846 AC_DEFINE_UNQUOTED(CMK_PPC_ASM, $strictpass, [Allows PPC assembly.])
847
848
849
850 #### test if we can use __thread ####
851 cat > $t <<EOT
852 __thread unsigned long long int x;
853 static __thread  int y;
854 void foo(void)
855 {
856         x = 1;
857         y = 1;
858 }
859 EOT
860 test_cxx "whether __thread (Thread Local Storage) is supported" "yes" "no" ""
861 AC_DEFINE_UNQUOTED(CMK_TLS_THREAD, $strictpass, [Allows __thread.])
862
863 ### test if switching TLS register ###
864 if test $in64bit = 1
865 then
866 cat > $t <<EOT
867 #include <elf.h>
868 #include <stdlib.h>
869 #include <malloc.h>
870
871 void switchTLS() {
872   Elf64_Addr m1, m2;
873   asm volatile ("movq %%fs:0x0, %0\n\t"
874                 "movq %1, %%fs:0x0\n\t"
875                 : "=r"(m1)
876                 : "r"(m2));
877 }
878 EOT
879 test_cxx "whether switching TLS register (64-bit) is supported" "yes" "no" ""
880 AC_DEFINE_UNQUOTED(CMK_TLS_SWITCHING64, $strictpass, [Allows switching TLS 64-bit.])
881 else
882 cat > $t <<EOT
883 #include <elf.h>
884 #include <stdlib.h>
885 #include <malloc.h>
886
887 void switchTLS() {
888   Elf32_Addr m1, m2;
889   asm volatile ("movl %%gs:0x0, %0\n\t"
890                 "movl %1, %%gs:0x0\n\t"
891                 : "=r"(m1)
892                 : "r"(m2));
893 }
894 EOT
895 test_cxx "whether switching TLS register (32-bit) is supported" "yes" "no" ""
896 AC_DEFINE_UNQUOTED(CMK_TLS_SWITCHING32, $strictpass, [Allows switching TLS in 32-bit.])
897 fi
898
899 #### test if we can build MPI ####
900 if test "$CMK_BUILD_MPI" = 1
901 then
902
903 cat > $t <<EOT
904 #include "mpi.h"
905 int main(int argc, char **argv)
906 {
907   MPI_Init(&argc, &argv);
908 }
909 EOT
910 mv -f ../include/mpi.h ../include/mpi.h.bak 2>/dev/null
911 test_cxx "whether build on MPI" "yes" "no" ""
912 AC_DEFINE_UNQUOTED(CMK_BUILD_ON_MPI, $strictpass, [build MPI.])
913 BUILD_MPI=$strictpass
914
915 if test $BUILD_MPI -eq 0
916 then
917   echo "Error: Can not compile a MPI program"
918   test_finish 1
919 fi
920
921 if test $BUILD_MPI -eq 1 -a -z "$BGP_FLOOR"
922 then
923   test_link "whether need to specify MPI library" "no" "yes" ""
924   if test $pass -ne 1
925   then
926     if test -z "$CMK_MPI_LIB"
927     then
928       test_link "whether -lmpich" "ok" "no" "-lmpich"
929       if test $pass -eq 1
930       then
931         add_flag CMK_SYSLIBS='"$CMK_SYSLIBS -lmpich"' "mpi lib"
932       else
933         test_link "whether -lmpi" "ok" "no" "-lmpi"
934         if test $pass -eq 1
935         then
936                 add_flag CMK_SYSLIBS='"$CMK_SYSLIBS -lmpi"' "mpi lib"
937         else
938                 echo "Error: can not find mpi library"
939                 test_finish 1
940         fi
941       fi
942     else
943       add_flag CMK_SYSLIBS='"$CMK_SYSLIBS $CMK_MPI_LIB"' "mpi lib"
944     fi
945   fi
946 fi
947
948 if test "$BUILD_MPI" = "1"
949 then
950 cat > $t <<EOT
951 #include "mpi.h"
952 int main(int argc, char **argv)
953 {
954   int thread_level, provided;
955   thread_level = MPI_THREAD_FUNNELED;
956   MPI_Init_thread(&argc, &argv, thread_level, &provided);
957 }
958 EOT
959 test_cxx "whether MPI_Init_thread is supported" "yes" "no" ""
960 AC_DEFINE_UNQUOTED(CMK_MPI_INIT_THREAD, $strictpass, [Allows MPI_Init_thread.])
961 fi
962 mv -f ../include/mpi.h.bak ../include/mpi.h 2>/dev/null
963
964 fi
965
966 ################### Syscalls and Libraries ###################
967
968 #### test for getrusage with RUSAGE_THREAD ###
969 cat > $tc <<EOT
970 #include <sys/time.h>
971 #define __USE_GNU   1
972 #include <sys/resource.h>
973 int main() {
974   struct rusage usage;
975   getrusage(RUSAGE_THREAD, &usage);
976   return 0;
977 }
978 EOT
979 test_linkc "whether getrusage accepts RUSAGE_THREAD" "yes" "no" ""
980 AC_DEFINE_UNQUOTED(CMK_HAS_RUSAGE_THREAD, $pass, [whether getrusage accepts RUSAGE_THREAD])
981
982 #### test for asctime ###
983
984 cat > $tc <<EOT
985 #include <time.h>
986 int main() {
987   struct tm *local;
988   time_t t;
989   t = time(NULL);
990   local = localtime(&t);
991   asctime(local);
992   return 0;
993 }
994 EOT
995 test_linkc "whether has asctime" "yes" "no" ""
996 AC_DEFINE_UNQUOTED(CMK_HAS_ASCTIME, $pass, [whether has asctime])
997
998 #### test for log2 ###
999 cat > $t <<EOT
1000 #include <math.h>
1001 int main() {
1002   int i = log2(10);
1003   return 0;
1004 }
1005 EOT
1006 test_link "whether has log2" "yes" "no" ""
1007 AC_DEFINE_UNQUOTED(CMK_HAS_LOG2, $pass, [whether has log2])
1008
1009 #### test for sqrtf ###
1010 cat > $t <<EOT
1011 #include <math.h>
1012 int main() {
1013   float i = sqrtf((float)10.0);
1014   return 0;
1015 }
1016 EOT
1017 test_link "whether has sqrtf" "yes" "no" ""
1018 AC_DEFINE_UNQUOTED(CMK_HAS_SQRTF, $pass, [whether has sqrtf])
1019
1020 #### test for fabsf ###
1021 cat > $t <<EOT
1022 #include <math.h>
1023 int main() {
1024   float i = fabsf((float)10.0);
1025   return 0;
1026 }
1027 EOT
1028 test_link "whether has fabsf" "yes" "no" ""
1029 AC_DEFINE_UNQUOTED(CMK_HAS_FABSF, $pass, [whether has fabsf])
1030
1031 #### test for mkstemp ###
1032 cat > $t <<EOT
1033 #include <stdlib.h>
1034 #include <string.h>
1035 int main() {
1036   char fname[[128]];
1037   strcpy(fname, "/tmp/fdXXX.XXX");
1038   mkstemp(fname);
1039   return 0;
1040 }
1041 EOT
1042 test_link "whether has mkstemp" "yes" "no" ""
1043 AC_DEFINE_UNQUOTED(CMK_USE_MKSTEMP, $pass, [whether has mkstemp])
1044
1045 #### test for system ###
1046 cat > $t <<EOT
1047 #include <stdlib.h>
1048 int main() {
1049   system("/bin/ls");
1050   return 0;
1051 }
1052 EOT
1053 test_link "whether has system" "yes" "no" ""
1054 AC_DEFINE_UNQUOTED(CMK_HAS_SYSTEM, $pass, [whether has system])
1055
1056 #### test for sbrk ###
1057 cat > $t <<EOT
1058 #include <unistd.h>
1059 int main() {
1060   void *ptr  = sbrk(0); 
1061 }
1062 EOT
1063 test_link "whether has sbrk" "yes" "no" ""
1064 AC_DEFINE_UNQUOTED(CMK_HAS_SBRK, $pass, [whether has sbrk])
1065
1066 #### test for _setjmp/_longjmp ###
1067 cat > $t <<EOT
1068 #include <setjmp.h>
1069 int main() {
1070   jmp_buf buf;
1071   _setjmp(buf);
1072   _longjmp(buf, 0);
1073 }
1074 EOT
1075 test_link "whether has _setjmp/_longjmp" "yes" "no" ""
1076 AC_DEFINE_UNQUOTED(CMK_HAS_UNDERSCORE_SETJMP, $pass, [whether has _setjmp/_longjmp])
1077
1078 #### test for mstats ###
1079 cat > $t <<EOT
1080 #include <malloc.h>
1081 int main() {
1082   struct mstats ms = mstats();
1083 }
1084 EOT
1085 test_link "whether has mstats" "yes" "no" ""
1086 AC_DEFINE_UNQUOTED(CMK_HAS_MSTATS, $pass, [whether has mstats])
1087
1088 #### test for mallinfo ###
1089 cat > $t <<EOT
1090 #include <malloc.h>
1091 int main() {
1092   struct mallinfo mi = mallinfo();
1093 }
1094 EOT
1095 test_link "whether has mallinfo" "yes" "no" ""
1096 AC_DEFINE_UNQUOTED(CMK_HAS_MALLINFO, $pass, [whether has mallinfo])
1097
1098 #### test for popen ###
1099 cat > $t <<EOT
1100 #include <stdio.h>
1101 int main() {
1102   FILE *p = popen("/bin/ps", "r");
1103   pclose(p);
1104 }
1105 EOT
1106 test_link "whether has popen" "yes" "no" ""
1107 AC_DEFINE_UNQUOTED(CMK_HAS_POPEN, $pass, [whether has popen])
1108
1109 #### test for poll ###
1110 cat > $t <<EOT
1111 #include <poll.h>
1112 void foo(void) { 
1113   struct pollfd pos[[3]];
1114   poll(pos, 1, 1);
1115 }
1116 EOT
1117 test_cxx "whether has poll" "yes" "no" ""
1118 AC_DEFINE_UNQUOTED(CMK_USE_POLL, $pass, [whether the poll syscall exists])
1119
1120 #### check if getpagesize exists ####
1121 cat > $tc <<EOT
1122 #include <unistd.h>
1123
1124 int main(int argc, char **argv) {
1125     int s = getpagesize();
1126 }
1127 EOT
1128 test_linkc "whether has getpagesize" "yes" "no" ""
1129 AC_DEFINE_UNQUOTED(CMK_HAS_GETPAGESIZE, $pass, [whether getpagesize exists])
1130
1131 #### check if getpid exists ####
1132 cat > $tc <<EOT
1133 #include <sys/types.h>
1134 #include <unistd.h>
1135
1136 int main(int argc, char **argv) {
1137     pid_t pid = getpid();
1138 }
1139 EOT
1140 test_linkc "whether has getpid" "yes" "no" ""
1141 AC_DEFINE_UNQUOTED(CMK_HAS_GETPID, $pass, [whether getpid exists])
1142
1143 #### check if kill exists ####
1144 cat > $tc <<EOT
1145 #include <sys/types.h>
1146 #include <unistd.h>
1147 #include <signal.h>
1148
1149 int main(int argc, char**argv) 
1150 {
1151     pid_t pid = getpid();
1152     kill(pid, 9);
1153 }
1154 EOT
1155 test_linkc "whether has kill" "yes" "no" ""
1156 AC_DEFINE_UNQUOTED(CMK_HAS_KILL, $pass, [whether kill exists])
1157
1158 #### test for setpriority ###
1159 cat > $t <<EOT
1160 #include <sys/time.h>
1161 #include <sys/resource.h>
1162 void foo(void) { 
1163   setpriority(PRIO_PROCESS, 0, 0);
1164 }
1165 EOT
1166 test_cxx "whether has setpriority" "yes" "no" ""
1167 AC_DEFINE_UNQUOTED(CMK_HAS_SETPRIORITY, $pass, [whether the setpriority exists])
1168
1169 #### test for system ###
1170 cat > $t <<EOT
1171 #include "ckdll_system.C"
1172 EOT
1173 test_cxx "whether to use signal-safe system() " "yes" "no" ""
1174 AC_DEFINE_UNQUOTED(CMK_SIGSAFE_SYSTEM, $pass, [whether to use signal-safe system()])
1175
1176 ### test sched_setaffinity ####
1177 cat > $tc <<EOT
1178 #define _GNU_SOURCE
1179 #include <sched.h>
1180
1181 int main()
1182 {
1183   cpu_set_t cpuset;
1184   CPU_ZERO(&cpuset);
1185   CPU_SET(0, &cpuset);
1186   if (sched_setaffinity(0, sizeof(cpuset), &cpuset) < 0) {
1187     return -1;
1188   }
1189   return 0;
1190 }
1191 EOT
1192 test_linkc "whether sched_setaffinity call exists" "yes" "no" ""
1193 AC_DEFINE_UNQUOTED(CMK_HAS_SETAFFINITY, $pass, [whether the sched_setaffinity() exists])
1194
1195 ### test pthread_setaffinity_np ####
1196 cat > $tc <<EOT
1197 #include <stdlib.h>
1198 #include <stdio.h>
1199 #include <unistd.h>
1200 #include <pthread.h>
1201
1202 int main()
1203 {
1204   unsigned long mask = 0xffffffff;
1205   unsigned int len = sizeof(mask);
1206
1207   if (pthread_setaffinity_np(pthread_self(), len, &mask) < 0) {
1208     return -1;
1209   }
1210   return 0;
1211 }
1212 EOT
1213 test_linkc "whether pthread_setaffinity_np call exists" "yes" "no" "-lpthread"
1214 AC_DEFINE_UNQUOTED(CMK_HAS_PTHREAD_SETAFFINITY, $pass, [whether the pthread_setaffinity_np() exists])
1215
1216
1217 ### check libnuma on Linux ####
1218 if test "$WITH_NUMA" = "yes"
1219 then
1220 cat > $tc <<EOT
1221 #include <stdlib.h>
1222 #include <stdio.h>
1223 #include <linux/mempolicy.h>
1224 #include <numaif.h>
1225 #include <numa.h>
1226
1227 int main()
1228 {
1229   if (get_mempolicy(NULL, NULL, 0, 0, 0) == 0) return 0;
1230   return -1;
1231 }
1232 EOT
1233 test_linkc "whether libnuma exists" "yes" "no" "-lnuma"
1234 AC_DEFINE_UNQUOTED(CMK_HAS_NUMACTRL, $pass, [whether NUMA control related functions exist])
1235 if test $pass -eq 1
1236 then
1237         add_flag 'CMK_SYSLIBS="$CMK_SYSLIBS -lnuma"' "libnuma"
1238 fi
1239 fi
1240
1241 #### check bindprocessors on AIX ####
1242 cat > $tc <<EOT
1243 #include <stdlib.h>
1244 #include <stdio.h>
1245 #include <unistd.h>
1246
1247 #include <sys/processor.h>
1248
1249 int main()
1250 {
1251   int retValue = 0;
1252   int pid;
1253   pid = getpid();
1254   if (bindprocessor(BINDPROCESS, pid, 0) == -1) return -1;
1255   return 0;
1256 }
1257 EOT
1258 test_linkc "whether bindprocessor call exists" "yes" "no" ""
1259 AC_DEFINE_UNQUOTED(CMK_HAS_BINDPROCESSOR, $pass, [whether the bindprocessor()
1260 exists])
1261
1262
1263 #### check if dlopen works ####
1264 skip_dl=0
1265 # for bproc, ignore -ldl
1266 test -n "$CMK_BPROC" && skip_dl=1
1267 test -n "$CMK_NO_DL" && skip_dl=1
1268 dl_opt='-ldl'
1269 #workaround for pgcc 4.0, -ldl crash linking, so use -Wl,-ldl to skip the prelinker.
1270 case "$CMK_CXX" in
1271 pgCC*) dl_opt='-Wl,-ldl' ;;
1272 esac
1273
1274 if test $skip_dl -eq 0 
1275 then
1276
1277 cat > $t <<EOT
1278 #include "ckdll_dlopen.C"
1279 int main() {
1280         CkDll dll("foo.so");
1281         return 0;
1282 }
1283 EOT
1284 test_link "whether dlopen links without $dl_opt" "yes" "no" ""
1285 noldl=$pass
1286 test_link "whether dlopen links with $dl_opt" "yes" "no" "$dl_opt"
1287 if test $pass -eq 1
1288 then 
1289 #dlopen requires -ldl: add it to our link line
1290         add_flag CMK_LIBS='"$CMK_LIBS '$dl_opt'"' "dlopen"
1291 fi
1292
1293 if test $pass -eq 1 -o $noldl -eq 1
1294 then
1295 # One version or another of dlopen worked: compile it in
1296         AC_DEFINE_UNQUOTED(CMK_DLL_USE_DLOPEN, 1, [dlopen])
1297 fi
1298
1299 ### test gethostname ####
1300 cat > $tc <<EOT
1301 #ifdef WIN32
1302 #include <Winsock2.h>
1303 #else
1304 #include <stdlib.h>
1305 #include <stdio.h>
1306 #include <unistd.h>
1307 #endif
1308
1309 int main()
1310 {
1311   char hostname[[1000]];
1312   gethostname(hostname, 999);
1313   return 0;
1314 }
1315 EOT
1316 test_linkc "whether gethostname call exists" "yes" "no" ""
1317 AC_DEFINE_UNQUOTED(CMK_HAS_GETHOSTNAME, $pass, [whether gethostname() exists])
1318
1319 #### check if getProcAddress works ####
1320 cat > $t <<EOT
1321 #include "ckdll_win32.C"
1322 EOT
1323 test_cxx "whether getProcAddress works" "yes" "no" ""
1324 AC_DEFINE_UNQUOTED(CMK_DLL_USE_WIN32, $pass, [whether getProcAddress works])
1325
1326 fi    # end of skip_dl
1327
1328 #### check if socklen_t exists ####
1329 cat > $t <<EOT
1330 #include <sys/types.h>
1331 #include <sys/socket.h>
1332
1333 void foo(void) {
1334         int i;
1335         socklen_t s=sizeof(i);
1336 }
1337 EOT
1338 test_cxx "whether has socklen_t" "yes" "no" ""
1339 AC_DEFINE_UNQUOTED(CMK_HAS_SOCKLEN, $pass, [whether has socklen_t])
1340
1341 ### test getifaddrs ####
1342 cat > $tc <<EOT
1343 #include <netinet/in.h> /* for sockaddr_in */
1344 #include <ifaddrs.h> /* for getifaddrs */
1345 #include <net/if.h> /* for IFF_RUNNING */
1346
1347 int main()
1348 {
1349   struct ifaddrs *interfaces=0;
1350   if( getifaddrs(&interfaces) == 0 ) {
1351         struct ifaddrs *interface;
1352         for( interface=interfaces; interface; interface=interface->ifa_next ) {
1353             if( (interface->ifa_flags & IFF_UP) && ! (interface->ifa_flags & IFF_LOOPBACK) ) {
1354                 const struct sockaddr_in *addr = (const struct sockaddr_in*)interface->ifa_addr;
1355                 if( addr && addr->sin_family==AF_INET ) {
1356                     break;
1357                 }
1358             }
1359         }
1360         freeifaddrs(interfaces);
1361   }
1362 }
1363 EOT
1364 test_linkc "whether getifaddrs call exists" "yes" "no" ""
1365 AC_DEFINE_UNQUOTED(CMK_HAS_GETIFADDRS, $pass, [whether getifaddrs() exists])
1366
1367 #### check if mmap exists ####
1368 cat > $t <<EOT
1369 #include <sys/types.h>
1370 #include <sys/mman.h>
1371
1372 void *foo(void *a,int l,int fd) {
1373         return mmap((caddr_t)a,l,PROT_READ+PROT_WRITE,
1374                  MAP_FIXED+MAP_PRIVATE,fd,0);
1375 }
1376 EOT
1377 test_cxx "whether the mmap() syscall exists" "yes" "no" ""
1378 AC_DEFINE_UNQUOTED(CMK_HAS_MMAP, $pass, [whether the mmap() syscall exists])
1379
1380 #### check if mmap accepts MAP_ANON ####
1381 cat > $t <<EOT
1382 #include <sys/types.h>
1383 #include <sys/mman.h>
1384
1385 void *foo(void *a,int l) {
1386         return mmap((caddr_t)a,l,PROT_READ+PROT_WRITE,
1387                 MAP_FIXED+MAP_PRIVATE+MAP_ANON,-1,0);
1388 }
1389 EOT
1390 test_cxx "whether mmap() accepts MAP_ANON" "yes" "no" ""
1391 AC_DEFINE_UNQUOTED(CMK_HAS_MMAP_ANON, $pass, [whether mmap() accepts MAP_ANON])
1392
1393 #### check if mmap accepts MAP_NORESERVE ####
1394 cat > $t <<EOT
1395 #include <sys/types.h>
1396 #include <sys/mman.h>
1397
1398 void *foo(void *a,int l) {
1399         return mmap((caddr_t)a,l,PROT_READ+PROT_WRITE,
1400                 MAP_FIXED+MAP_PRIVATE+MAP_NORESERVE,-1,0);
1401 }
1402 EOT
1403 test_cxx "whether mmap() accepts MAP_NORESERVE" "yes" "no" ""
1404 AC_DEFINE_UNQUOTED(CMK_HAS_MMAP_NORESERVE, $pass, [whether mmap() accepts MAP_NORESERVE])
1405
1406 #### check if get_myaddress exists ####
1407 cat > $t <<EOT
1408 #include <rpc/rpc.h>
1409
1410 void foo(void *a) {
1411     get_myaddress((struct sockaddr_in*)a);
1412 }
1413 EOT
1414 test_cxx "whether has get_myaddress" "yes" "no" ""
1415 AC_DEFINE_UNQUOTED(CMK_HAS_GET_MYADDRESS, $pass, [whether has get_myaddress])
1416
1417 #### check if mprotect exists ####
1418 cat > $t <<EOT
1419 #include <stdio.h>
1420 #include <sys/mman.h>
1421
1422 void foo(void *a,int l,int fd) {
1423      void *pg = NULL;
1424      size_t pagesize = 4096;
1425      mprotect(pg, pagesize, PROT_READ | PROT_WRITE);
1426 }
1427 EOT
1428 test_cxx "whether has mprotect" "yes" "no" ""
1429 AC_DEFINE_UNQUOTED(CMK_HAS_MPROTECT, $pass, [whether has mprotect])
1430
1431 #### check if glibc backtrace exists ####
1432 cat > $t <<EOT
1433 #include "cmibacktrace.c"
1434
1435 int main() {
1436         int nLevels=1;
1437         void *stack;
1438         CmiBacktraceRecord(&stack,0,&nLevels);
1439         return 0;
1440 }
1441 EOT
1442 TRACE_LINK_FLAG="-rdynamic"
1443 test_link "whether glibc backtrace works" "yes" "no" "-DCMK_USE_BACKTRACE=1 $TRACE_LINK_FLAG"
1444 AC_DEFINE_UNQUOTED(CMK_USE_BACKTRACE, $pass, [whether glibc backtrace works])
1445
1446 if test $strictpass -eq 1
1447 then 
1448         add_flag 'CMK_LD="$CMK_LD '$TRACE_LINK_FLAG'"' "backtrace"
1449         add_flag 'CMK_LDXX="$CMK_LDXX '$TRACE_LINK_FLAG'"' "backtrace"
1450 fi
1451
1452 #### test sleep ####
1453 cat > $t <<EOT
1454 #include <unistd.h>
1455 int main() {
1456   sleep(1);
1457   return 0;
1458 }
1459 EOT
1460 test_cxx "whether has sleep " "yes" "no" ""
1461 AC_DEFINE_UNQUOTED(CMK_HAS_SLEEP, $pass, [whether has sleep])
1462
1463 #### test usleep ####
1464 cat > $t <<EOT
1465 #include <unistd.h>
1466 int main() {
1467   usleep(100);
1468   return 0;
1469 }
1470 EOT
1471 test_cxx "whether has usleep " "yes" "no" ""
1472 AC_DEFINE_UNQUOTED(CMK_HAS_USLEEP, $pass, [whether has usleep])
1473
1474 #### test personality() and ADDR_NO_RANDOMIZE ####
1475 # Only works on modern Linux systems
1476 cat > $t <<EOT
1477 #include <sys/personality.h>
1478 int main() {
1479     int orig_persona = personality(0xffffffff);
1480     personality(orig_persona | ADDR_NO_RANDOMIZE);
1481     return 0;
1482 }
1483 EOT
1484 test_cxx "whether personality() and ADDR_NO_RANDOMIZE exist" "yes" "no" ""
1485 AC_DEFINE_UNQUOTED(CMK_HAS_ADDR_NO_RANDOMIZE, $pass, [whether personality() and ADDR_NO_RANDOMIZE exist])
1486
1487
1488 #### test if has zlib ####
1489 # bproc doesnot like -lz in any case
1490 if test -z "$CMK_BPROC"
1491 then
1492
1493 cat > $t <<EOT
1494 #include <zlib.h>
1495 int main() { 
1496   gzFile f = gzopen("/tmp/x","r");
1497   gzprintf(f, "test...\n");
1498   gzclose(f);
1499   return 0;
1500 }
1501 EOT
1502 test_link "whether has zlib" "yes" "no" "-lz"
1503 AC_DEFINE_UNQUOTED(CMK_PROJECTIONS_USE_ZLIB, $pass, [whether has zlib])
1504 if test $pass -eq 1
1505 then 
1506         add_flag 'CMK_LIBZ="-lz"' "zlib"
1507 fi
1508
1509 fi
1510
1511 #### test if has elf.h ####
1512 cat > $t <<EOT
1513 #include <elf.h>
1514 typedef Elf32_Addr ELF_TYPE_Addr;
1515 int main() { 
1516 }
1517 EOT
1518 test_cxx "whether has elf.h " "yes" "no" ""
1519 AC_DEFINE_UNQUOTED([CMK_HAS_ELF_H], $pass, [whether has elf.h])
1520
1521 #### test if has Multiprocessing.h for apple ####
1522 cat > $t <<EOT
1523 #include <Carbon/Carbon.h>
1524 #include <Multiprocessing.h>
1525 int main() {
1526   int a = MPProcessorsScheduled();
1527 }
1528 EOT
1529 test_cxx "whether has Multiprocessing.h for Apple " "yes" "no" ""
1530 AC_DEFINE_UNQUOTED([CMK_HAS_MULTIPROCESSING_H], $pass, [whether has Multiprocessing.h])
1531
1532 #### test if "ntohl" is available ####
1533 cat > $t <<EOT
1534 #if defined(_WIN32) && ! defined(__CYGWIN__) || defined(__MINGW_H)
1535 #include <winsock.h>
1536 #else
1537 #include <netinet/in.h>
1538 #include <arpa/inet.h>
1539 #endif
1540
1541 int main() {
1542   int i = 100;
1543   i = ntohl(i);
1544   return 0;
1545 }
1546 EOT
1547 test_link "whether ntohl is available" "yes" "no" ""
1548 AC_DEFINE_UNQUOTED(CMK_HAS_NTOHL, $pass, [whether ntohl is available])
1549
1550 ### test for libjpeg ####
1551 cat > $t <<EOT
1552 #include <stdio.h>
1553 #include <stdlib.h>
1554 #include "jpeglib.h"
1555
1556 int main()
1557 {
1558   struct jpeg_compress_struct cinfo;
1559   jpeg_create_compress(&cinfo);
1560   return 0;
1561 }
1562 EOT
1563 test_link "whether has libjpeg" "yes" "no" "-ljpeg"
1564 AC_DEFINE_UNQUOTED(CMK_USE_LIBJPEG, $pass, [whether has libjpeg])
1565 if test $pass -eq 1
1566 then
1567         add_flag 'CMK_LIBJPEG="-ljpeg"' "libjpeg"
1568 fi
1569
1570 #### check if PAPI exists ####
1571 if test -n "$CMK_USE_PAPI"
1572 then
1573 cat > $t <<EOT
1574 #include <stdio.h>
1575 #include <papi.h>
1576                                                                                 
1577 int main() {
1578     if (PAPI_library_init(PAPI_VER_CURRENT) != PAPI_VER_CURRENT) return 1;
1579     return 0;
1580 }
1581 EOT
1582 test_link "whether PAPI exists" "yes" "no" "-lpapi"
1583 AC_DEFINE_UNQUOTED(CMK_HAS_COUNTER_PAPI, $pass, [whether PAPI exists])
1584 if test $pass -eq 1
1585 then 
1586         add_flag 'CMK_LIBS="$CMK_LIBS -lpapi"' "papi"
1587 fi
1588 fi
1589
1590 #### test if Python headers are installed ####
1591 PYTHON_VERSION=`python -V 2>&1 | awk {'print $2'} | awk -F. {'print $1"."$2'}`
1592 cat > $t <<EOT
1593 #include "python${PYTHON_VERSION}/Python.h"
1594 #include "python${PYTHON_VERSION}/compile.h"
1595 #include "python${PYTHON_VERSION}/eval.h"
1596 #include "python${PYTHON_VERSION}/node.h"
1597
1598 int main() {
1599     Py_Initialize();
1600     PyEval_InitThreads();
1601     struct _node* programNode = PyParser_SimpleParseString("return 1\n",Py_file_input);
1602     PyCodeObject *program = PyNode_Compile(programNode, "");
1603 }
1604 EOT
1605 test_link "whether Python is installed" "yes" "no" "-lpython$PYTHON_VERSION -lpthread -lutil -ldl"
1606 AC_DEFINE_UNQUOTED(CMK_HAS_PYTHON, $pass, [whether Python is installed])
1607 AC_DEFINE_UNQUOTED(CMK_PYTHON_VERSION, ${PYTHON_VERSION}, [Python version])
1608 if test $pass -eq 1
1609 then
1610         add_flag "CMK_BUILD_PYTHON=$PYTHON_VERSION" "python"
1611 fi
1612
1613 #### Pick up METIS if the user asks for it ####
1614
1615 AC_ARG_WITH([metis],
1616             [AS_HELP_STRING([--with-metis],
1617              [support the METIS graph partitioner and associated load balancer])],
1618             [],
1619             [with_metis=no])
1620
1621 WITH_METIS=no
1622 if test "$with_metis" != "no"
1623 then
1624   Echo "Compiling Charm with support for METIS"
1625   WITH_METIS=yes
1626   echo 'charm++: $(L)/libmoduleMetisLB.a $(L)/libmoduleTeamLB.a' >> $MAKEFILE_EXT
1627   add_flag 'CMK_LIBS="$CMK_LIBS -lmetis"' "libmetis"
1628   if test "$with_metis" != "yes"
1629   then
1630     add_flag "CMK_METIS=$with_metis" "Where to find METIS"
1631     add_flag 'CMK_LIBDIR="$CMK_LIBDIR -L$CMK_METIS"' "Library path for METIS"
1632     if test -r $with_metis/Lib/metis.h
1633     then
1634       add_flag 'CMK_INCDIR="$CMK_INCDIR -I$CMK_METIS/Lib"' "Include path for METIS 4"
1635     elif test -r $with_metis/../../include/metis.h
1636     then
1637       add_flag 'CMK_INCDIR="$CMK_INCDIR -I$CMK_METIS/../../include"' "Include path for METIS 5"
1638     else
1639       echo "I can't find metis.h, since the path you specified (which should point to the directory containing libmetis.a) is not laid out as I expect for version 4 or 5."
1640       test_finish 1
1641     fi
1642   fi
1643 fi
1644
1645 ## Cray specific test
1646 if test "$CMK_BUILD_CRAY" = "1"
1647 then
1648
1649 #### test if Cray node topology will work ####
1650 cat > $tc <<EOT
1651 #include <pmi.h>
1652
1653 int main() {
1654     int nid;
1655     PMI_Get_nid(0, &nid);
1656
1657     return 0;
1658 }
1659 EOT
1660 test_linkc "whether PMI_Get_nid exists" "yes" "no" ""
1661 AC_DEFINE_UNQUOTED(CMK_HAS_PMI_GET_NID, $pass, [whether PMI_Get_nid exists])
1662
1663 #### test if Cray mesh topology will work ####
1664 cat > $tc <<EOT
1665 #include <rca_lib.h>
1666
1667 int main() {
1668     rca_mesh_coord_t xyz;
1669     rca_get_meshcoord(0, &xyz);
1670
1671     return 0;
1672 }
1673 EOT
1674 test_linkc "whether Cray rca library is available" "yes" "no" "-lrca"
1675 AC_DEFINE_UNQUOTED(CMK_HAS_RCALIB, $pass, [whether Cray rca library is available])
1676
1677 fi
1678
1679 #### test if it can build shared library ####
1680 cat > $t <<EOT
1681 #include "stdlib.h"
1682 extern int foo();
1683 int foo1() { 
1684   void * t= malloc(2);
1685   foo();
1686   return 0;
1687 }
1688 EOT
1689 test_linkso "whether can build shared library" "yes" "no" ""
1690 if test $pass -eq 0
1691 then 
1692         add_flag 'CMK_NO_BUILD_SHARED="true"' "build-shared"
1693 else
1694         BUILD_SHARED=1
1695         if test "$BUILD_MPI" = "1"
1696         then
1697 cat > $t <<EOT
1698 #include "stdlib.h"
1699 #include "mpi.h"
1700 extern int foo();
1701 int foo(int argc, char ** argv) {
1702   void * t= malloc(2);
1703   foo();
1704   MPI_Init(&argc, &argv);
1705   return 0;
1706 }
1707 EOT
1708                 test_linkso "whether can build shared library with MPI" "yes" "no" ""
1709                 BUILD_SHARED=$pass
1710         fi
1711         if test $BUILD_SHARED -eq 0
1712         then
1713                 add_flag 'CMK_NO_BUILD_SHARED="true"' "build-shared"
1714         fi
1715 fi
1716
1717 #### test the version number of bproc ####
1718 if test -n "$CMK_BPROC"
1719 then
1720 cat > $t <<EOT
1721 #include <stdio.h>
1722 #include <sys/bproc.h>
1723 int main()
1724 {
1725   struct bproc_version_t vers;
1726   bproc_version(&vers);
1727   printf("%s\n", vers.version_string);
1728 }
1729 EOT
1730 test_link "whether bproc compiles" "yes" "no" "-lbproc"
1731 if test $pass -eq 1
1732 then 
1733 AC_MSG_CHECKING("bproc version")
1734 bproc_ver=`./testlink`
1735 if test x$bproc_ver = x
1736 then
1737 test_result 0 "bproc version" "ERROR" ""
1738 test_finish 1
1739 else
1740 test_result 0 "bproc version" "$bproc_ver" ""
1741 fi
1742 bproc_ver=`echo $bproc_ver | cut -d'.' -f1`
1743 AC_DEFINE_UNQUOTED(CMK_BPROC_VERSION, $bproc_ver, [bproc version])
1744 fi
1745 fi
1746
1747 #### test the if command sync exists ####
1748 AC_CHECK_PROG(SYNC, sync, sync )
1749 if test -n "$SYNC"
1750 then
1751 AC_DEFINE_UNQUOTED(CMK_HAS_SYNC, 1, [sync program])
1752 fi
1753
1754 ################## Fortran #########################
1755
1756 #echo "set F77 compiler as: $CMK_CF77"
1757 AC_MSG_CHECKING("F77 compiler as")
1758 AC_MSG_RESULT("$CMK_CF77")
1759
1760 AC_MSG_CHECKING("whether Fortran 77 compiler works")
1761 ### test fortran 77 compiler ###
1762 cat > conftest.f <<EOF
1763       SUBROUTINE FOO_foo
1764       END
1765 EOF
1766 $CMK_CF77 -c conftest.f > /dev/null 2> /dev/null
1767 if test ! -r conftest.o
1768 then
1769   AC_MSG_RESULT("no")
1770 else
1771   AC_MSG_RESULT("yes")
1772 fi
1773
1774 ### test fortran 90 compiler ###
1775 #echo "set F90 compiler as: $CMK_CF90"
1776 AC_MSG_CHECKING("F90 compiler as")
1777 AC_MSG_RESULT("$CMK_CF90")
1778
1779 AC_MSG_CHECKING("whether Fortran 90 compiler works")
1780 cat > conftest2.f90 <<EOF
1781       SUBROUTINE FOO_foo
1782       END
1783 EOF
1784 $CMK_CF90 -c conftest2.f90 > /dev/null 2> /dev/null
1785 if test ! -r conftest2.o
1786 then
1787   AC_MSG_RESULT("no")
1788 else
1789   AC_MSG_RESULT("yes")
1790   mv -f conftest2.o conftest.o
1791   USE_FORTRAN90=1
1792 fi
1793
1794 ### check fortran name mangling
1795 AC_MSG_CHECKING(subroutine name used by Fortran 90 compiler)
1796
1797 if test -r conftest.o
1798 then
1799   AC_CACHE_VAL(_cv_fortran_postfix,
1800
1801   NAME=`$CMK_NM conftest.o | grep "foo_foo__"`
1802   if test "$NAME" != ""
1803   then
1804     _cv_fortran_postfix=TWOSCORE
1805     AC_DEFINE_UNQUOTED(CMK_FORTRAN_USES_TWOSCORE, 1, [TWOSCORE])
1806   else
1807     NAME=`$CMK_NM conftest.o | grep "foo_foo_"`
1808     if test "$NAME" != ""
1809     then
1810       _cv_fortran_postfix=ONESCORE
1811       AC_DEFINE_UNQUOTED(CMK_FORTRAN_USES_ONESCORE, 1, [ONESCORE])
1812     else
1813       NAME=`$CMK_NM conftest.o | grep "foo_foo"`
1814       if test "$NAME" != ""
1815       then
1816         _cv_fortran_postfix=NOSCORE
1817         AC_DEFINE_UNQUOTED(CMK_FORTRAN_USES_NOSCORE, 1, [NOSCORE])
1818       else
1819         NAME=`$CMK_NM conftest.o | grep "FOO_FOO"`
1820         if test "$NAME" != ""
1821         then
1822           _cv_fortran_postfix=ALLCAPS
1823           AC_DEFINE_UNQUOTED(CMK_FORTRAN_USES_ALLCAPS, 1, [ALLCAPS])
1824         else
1825           echo "#################################################"
1826           echo "FORTRAN compiler generated name not supported yet"
1827           echo "#################################################"
1828         fi
1829       fi
1830     fi
1831   fi
1832   rm -f conftest.f conftest.o
1833   )
1834   AC_MSG_RESULT($_cv_fortran_postfix)
1835 else
1836   AC_MSG_RESULT("Fortran compiler not working")
1837 fi
1838
1839 ### check module name ###
1840
1841 if test "$USE_FORTRAN90" = 1
1842 then
1843   cat > conftest.f90 <<EOF
1844       MODULE testmod
1845         interface 
1846           function fpup_issizing(p)
1847           INTEGER :: p
1848           logical fpup_issizing
1849           end function
1850         end interface
1851       END MODULE
1852 EOF
1853   AC_MSG_CHECKING(Fortran 90 mod name is capital)
1854   $CMK_CF90 -c conftest.f90 > /dev/null 2> /dev/null
1855   name=`ls TESTMOD.* 2>/dev/null`
1856   if test -n "$name"
1857   then
1858         AC_MSG_RESULT("yes")
1859         add_flag 'CMK_MOD_NAME_ALLCAPS=1' "mod name capital"
1860   else
1861         AC_MSG_RESULT("no")
1862         name=`ls testmod.* 2>/dev/null`
1863   fi
1864   if test -n "$name"
1865   then
1866         AC_MSG_CHECKING(Fortran 90 mod name extension)
1867         ext=`echo $name | sed -e 's/^[[^.]]*\.//'`
1868         add_flag 'CMK_MOD_EXT="'$ext'"' "mod name extension"
1869         AC_MSG_RESULT("$ext")
1870         /bin/rm -f $name
1871   fi
1872   /bin/rm -f conftest.f90
1873 fi
1874
1875 AC_OUTPUT(
1876 libs/ck-libs/ampi/ampiCC libs/ck-libs/ampi/ampirun,
1877
1878 chmod +x libs/ck-libs/ampi/ampiCC libs/ck-libs/ampi/ampirun
1879 )