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