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