2cf0b0307718a4b439c0b8537d70dccf76ed089f
[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=60304
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 log2 ###
942 cat > $t <<EOT
943 #include <math.h>
944 int main() {
945   int i = log2(10);
946   return 0;
947 }
948 EOT
949 test_link "whether has log2" "yes" "no" ""
950 AC_DEFINE_UNQUOTED(CMK_HAS_LOG2, $pass, [whether has log2])
951
952 #### test for sqrtf ###
953 cat > $t <<EOT
954 #include <math.h>
955 int main() {
956   float i = sqrtf((float)10.0);
957   return 0;
958 }
959 EOT
960 test_link "whether has sqrtf" "yes" "no" ""
961 AC_DEFINE_UNQUOTED(CMK_HAS_SQRTF, $pass, [whether has sqrtf])
962
963 #### test for fabsf ###
964 cat > $t <<EOT
965 #include <math.h>
966 int main() {
967   float i = fabsf((float)10.0);
968   return 0;
969 }
970 EOT
971 test_link "whether has fabsf" "yes" "no" ""
972 AC_DEFINE_UNQUOTED(CMK_HAS_FABSF, $pass, [whether has fabsf])
973
974 #### test for mkstemp ###
975 cat > $t <<EOT
976 #include <stdlib.h>
977 #include <string.h>
978 int main() {
979   char fname[[128]];
980   strcpy(fname, "/tmp/fdXXX.XXX");
981   mkstemp(fname);
982   return 0;
983 }
984 EOT
985 test_link "whether has mkstemp" "yes" "no" ""
986 AC_DEFINE_UNQUOTED(CMK_USE_MKSTEMP, $pass, [whether has mkstemp])
987
988 #### test for system ###
989 cat > $t <<EOT
990 #include <stdlib.h>
991 int main() {
992   system("/bin/ls");
993   return 0;
994 }
995 EOT
996 test_link "whether has system" "yes" "no" ""
997 AC_DEFINE_UNQUOTED(CMK_HAS_SYSTEM, $pass, [whether has system])
998
999 #### test for sbrk ###
1000 cat > $t <<EOT
1001 #include <unistd.h>
1002 int main() {
1003   void *ptr  = sbrk(0); 
1004 }
1005 EOT
1006 test_link "whether has sbrk" "yes" "no" ""
1007 AC_DEFINE_UNQUOTED(CMK_HAS_SBRK, $pass, [whether has sbrk])
1008
1009 #### test for _setjmp/_longjmp ###
1010 cat > $t <<EOT
1011 #include <setjmp.h>
1012 int main() {
1013   jmp_buf buf;
1014   _setjmp(buf);
1015   _longjmp(buf, 0);
1016 }
1017 EOT
1018 test_link "whether has _setjmp/_longjmp" "yes" "no" ""
1019 AC_DEFINE_UNQUOTED(CMK_HAS_UNDERSCORE_SETJMP, $pass, [whether has _setjmp/_longjmp])
1020
1021 #### test for mstats ###
1022 cat > $t <<EOT
1023 #include <malloc.h>
1024 int main() {
1025   struct mstats ms = mstats();
1026 }
1027 EOT
1028 test_link "whether has mstats" "yes" "no" ""
1029 AC_DEFINE_UNQUOTED(CMK_HAS_MSTATS, $pass, [whether has mstats])
1030
1031 #### test for mallinfo ###
1032 cat > $t <<EOT
1033 #include <malloc.h>
1034 int main() {
1035   struct mallinfo mi = mallinfo();
1036 }
1037 EOT
1038 test_link "whether has mallinfo" "yes" "no" ""
1039 AC_DEFINE_UNQUOTED(CMK_HAS_MALLINFO, $pass, [whether has mallinfo])
1040
1041 #### test for popen ###
1042 cat > $t <<EOT
1043 #include <stdio.h>
1044 int main() {
1045   FILE *p = popen("/bin/ps", "r");
1046   pclose(p);
1047 }
1048 EOT
1049 test_link "whether has popen" "yes" "no" ""
1050 AC_DEFINE_UNQUOTED(CMK_HAS_POPEN, $pass, [whether has popen])
1051
1052 #### test for poll ###
1053 cat > $t <<EOT
1054 #include <poll.h>
1055 void foo(void) { 
1056   struct pollfd pos[[3]];
1057   poll(pos, 1, 1);
1058 }
1059 EOT
1060 test_cxx "whether has poll" "yes" "no" ""
1061 AC_DEFINE_UNQUOTED(CMK_USE_POLL, $pass, [whether the poll syscall exists])
1062
1063 #### check if getpagesize exists ####
1064 cat > $tc <<EOT
1065 #include <unistd.h>
1066
1067 int main(int argc, char **argv) {
1068     int s = getpagesize();
1069 }
1070 EOT
1071 test_linkc "whether has getpagesize" "yes" "no" ""
1072 AC_DEFINE_UNQUOTED(CMK_HAS_GETPAGESIZE, $pass, [whether getpagesize exists])
1073
1074 #### check if getpid exists ####
1075 cat > $tc <<EOT
1076 #include <sys/types.h>
1077 #include <unistd.h>
1078
1079 int main(int argc, char **argv) {
1080     pid_t pid = getpid();
1081 }
1082 EOT
1083 test_linkc "whether has getpid" "yes" "no" ""
1084 AC_DEFINE_UNQUOTED(CMK_HAS_GETPID, $pass, [whether getpid exists])
1085
1086 #### check if kill exists ####
1087 cat > $tc <<EOT
1088 #include <sys/types.h>
1089 #include <unistd.h>
1090 #include <signal.h>
1091
1092 int main(int argc, char**argv) 
1093 {
1094     pid_t pid = getpid();
1095     kill(pid, 9);
1096 }
1097 EOT
1098 test_linkc "whether has kill" "yes" "no" ""
1099 AC_DEFINE_UNQUOTED(CMK_HAS_KILL, $pass, [whether kill exists])
1100
1101 #### test for setpriority ###
1102 cat > $t <<EOT
1103 #include <sys/time.h>
1104 #include <sys/resource.h>
1105 void foo(void) { 
1106   setpriority(PRIO_PROCESS, 0, 0);
1107 }
1108 EOT
1109 test_cxx "whether has setpriority" "yes" "no" ""
1110 AC_DEFINE_UNQUOTED(CMK_HAS_SETPRIORITY, $pass, [whether the setpriority exists])
1111
1112 #### test for system ###
1113 cat > $t <<EOT
1114 #include "ckdll_system.C"
1115 EOT
1116 test_cxx "whether to use signal-safe system() " "yes" "no" ""
1117 AC_DEFINE_UNQUOTED(CMK_SIGSAFE_SYSTEM, $pass, [whether to use signal-safe system()])
1118
1119 ### test sched_setaffinity ####
1120 cat > $tc <<EOT
1121 #define _GNU_SOURCE
1122 #include <sched.h>
1123
1124 int main()
1125 {
1126   cpu_set_t cpuset;
1127   CPU_ZERO(&cpuset);
1128   CPU_SET(0, &cpuset);
1129   if (sched_setaffinity(0, sizeof(cpuset), &cpuset) < 0) {
1130     return -1;
1131   }
1132   return 0;
1133 }
1134 EOT
1135 test_linkc "whether sched_setaffinity call exists" "yes" "no" ""
1136 AC_DEFINE_UNQUOTED(CMK_HAS_SETAFFINITY, $pass, [whether the sched_setaffinity() exists])
1137
1138 ### test pthread_setaffinity_np ####
1139 cat > $tc <<EOT
1140 #include <stdlib.h>
1141 #include <stdio.h>
1142 #include <unistd.h>
1143 #include <pthread.h>
1144
1145 int main()
1146 {
1147   unsigned long mask = 0xffffffff;
1148   unsigned int len = sizeof(mask);
1149
1150   if (pthread_setaffinity_np(pthread_self(), len, &mask) < 0) {
1151     return -1;
1152   }
1153   return 0;
1154 }
1155 EOT
1156 test_linkc "whether pthread_setaffinity_np call exists" "yes" "no" "-lpthread"
1157 AC_DEFINE_UNQUOTED(CMK_HAS_PTHREAD_SETAFFINITY, $pass, [whether the pthread_setaffinity_np() exists])
1158
1159
1160 ### check libnuma on Linux ####
1161 if test "$WITH_NUMA" = "yes"
1162 then
1163 cat > $tc <<EOT
1164 #include <stdlib.h>
1165 #include <stdio.h>
1166 #include <linux/mempolicy.h>
1167 #include <numaif.h>
1168 #include <numa.h>
1169
1170 int main()
1171 {
1172   if (get_mempolicy(NULL, NULL, 0, 0, 0) == 0) return 0;
1173   return -1;
1174 }
1175 EOT
1176 test_linkc "whether libnuma exists" "yes" "no" "-lnuma"
1177 AC_DEFINE_UNQUOTED(CMK_HAS_NUMACTRL, $pass, [whether NUMA control related functions exist])
1178 if test $pass -eq 1
1179 then
1180         add_flag 'CMK_SYSLIBS="$CMK_SYSLIBS -lnuma"' "libnuma"
1181 fi
1182 fi
1183
1184 #### check bindprocessors on AIX ####
1185 cat > $tc <<EOT
1186 #include <stdlib.h>
1187 #include <stdio.h>
1188 #include <unistd.h>
1189
1190 #include <sys/processor.h>
1191
1192 int main()
1193 {
1194   int retValue = 0;
1195   int pid;
1196   pid = getpid();
1197   if (bindprocessor(BINDPROCESS, pid, 0) == -1) return -1;
1198   return 0;
1199 }
1200 EOT
1201 test_linkc "whether bindprocessor call exists" "yes" "no" ""
1202 AC_DEFINE_UNQUOTED(CMK_HAS_BINDPROCESSOR, $pass, [whether the bindprocessor()
1203 exists])
1204
1205
1206 #### check if dlopen works ####
1207 skip_dl=0
1208 # for bproc, ignore -ldl
1209 test -n "$CMK_BPROC" && skip_dl=1
1210 test -n "$CMK_NO_DL" && skip_dl=1
1211 dl_opt='-ldl'
1212 #workaround for pgcc 4.0, -ldl crash linking, so use -Wl,-ldl to skip the prelinker.
1213 case "$CMK_CXX" in
1214 pgCC*) dl_opt='-Wl,-ldl' ;;
1215 esac
1216
1217 if test $skip_dl -eq 0 
1218 then
1219
1220 cat > $t <<EOT
1221 #include "ckdll_dlopen.C"
1222 int main() {
1223         CkDll dll("foo.so");
1224         return 0;
1225 }
1226 EOT
1227 test_link "whether dlopen links without $dl_opt" "yes" "no" ""
1228 noldl=$pass
1229 test_link "whether dlopen links with $dl_opt" "yes" "no" "$dl_opt"
1230 if test $pass -eq 1
1231 then 
1232 #dlopen requires -ldl: add it to our link line
1233         add_flag CMK_LIBS='"$CMK_LIBS '$dl_opt'"' "dlopen"
1234 fi
1235
1236 if test $pass -eq 1 -o $noldl -eq 1
1237 then
1238 # One version or another of dlopen worked: compile it in
1239         AC_DEFINE_UNQUOTED(CMK_DLL_USE_DLOPEN, 1, [dlopen])
1240 fi
1241
1242 ### test gethostname ####
1243 cat > $tc <<EOT
1244 #ifdef WIN32
1245 #include <Winsock2.h>
1246 #else
1247 #include <stdlib.h>
1248 #include <stdio.h>
1249 #include <unistd.h>
1250 #endif
1251
1252 int main()
1253 {
1254   char hostname[[1000]];
1255   gethostname(hostname, 999);
1256   return 0;
1257 }
1258 EOT
1259 test_linkc "whether gethostname call exists" "yes" "no" ""
1260 AC_DEFINE_UNQUOTED(CMK_HAS_GETHOSTNAME, $pass, [whether gethostname() exists])
1261
1262 #### check if getProcAddress works ####
1263 cat > $t <<EOT
1264 #include "ckdll_win32.C"
1265 EOT
1266 test_cxx "whether getProcAddress works" "yes" "no" ""
1267 AC_DEFINE_UNQUOTED(CMK_DLL_USE_WIN32, $pass, [whether getProcAddress works])
1268
1269 fi    # end of skip_dl
1270
1271 #### check if socklen_t exists ####
1272 cat > $t <<EOT
1273 #include <sys/types.h>
1274 #include <sys/socket.h>
1275
1276 void foo(void) {
1277         int i;
1278         socklen_t s=sizeof(i);
1279 }
1280 EOT
1281 test_cxx "whether has socklen_t" "yes" "no" ""
1282 AC_DEFINE_UNQUOTED(CMK_HAS_SOCKLEN, $pass, [whether has socklen_t])
1283
1284 ### test getifaddrs ####
1285 cat > $tc <<EOT
1286 #include <netinet/in.h> /* for sockaddr_in */
1287 #include <ifaddrs.h> /* for getifaddrs */
1288 #include <net/if.h> /* for IFF_RUNNING */
1289
1290 int main()
1291 {
1292   struct ifaddrs *interfaces=0;
1293   if( getifaddrs(&interfaces) == 0 ) {
1294         struct ifaddrs *interface;
1295         for( interface=interfaces; interface; interface=interface->ifa_next ) {
1296             if( (interface->ifa_flags & IFF_UP) && ! (interface->ifa_flags & IFF_LOOPBACK) ) {
1297                 const struct sockaddr_in *addr = (const struct sockaddr_in*)interface->ifa_addr;
1298                 if( addr && addr->sin_family==AF_INET ) {
1299                     break;
1300                 }
1301             }
1302         }
1303         freeifaddrs(interfaces);
1304   }
1305 }
1306 EOT
1307 test_linkc "whether getifaddrs call exists" "yes" "no" ""
1308 AC_DEFINE_UNQUOTED(CMK_HAS_GETIFADDRS, $pass, [whether getifaddrs() exists])
1309
1310 #### check if mmap exists ####
1311 cat > $t <<EOT
1312 #include <sys/types.h>
1313 #include <sys/mman.h>
1314
1315 void *foo(void *a,int l,int fd) {
1316         return mmap((caddr_t)a,l,PROT_READ+PROT_WRITE,
1317                  MAP_FIXED+MAP_PRIVATE,fd,0);
1318 }
1319 EOT
1320 test_cxx "whether the mmap() syscall exists" "yes" "no" ""
1321 AC_DEFINE_UNQUOTED(CMK_HAS_MMAP, $pass, [whether the mmap() syscall exists])
1322
1323 #### check if mmap accepts MAP_ANON ####
1324 cat > $t <<EOT
1325 #include <sys/types.h>
1326 #include <sys/mman.h>
1327
1328 void *foo(void *a,int l) {
1329         return mmap((caddr_t)a,l,PROT_READ+PROT_WRITE,
1330                 MAP_FIXED+MAP_PRIVATE+MAP_ANON,-1,0);
1331 }
1332 EOT
1333 test_cxx "whether mmap() accepts MAP_ANON" "yes" "no" ""
1334 AC_DEFINE_UNQUOTED(CMK_HAS_MMAP_ANON, $pass, [whether mmap() accepts MAP_ANON])
1335
1336 #### check if mmap accepts MAP_NORESERVE ####
1337 cat > $t <<EOT
1338 #include <sys/types.h>
1339 #include <sys/mman.h>
1340
1341 void *foo(void *a,int l) {
1342         return mmap((caddr_t)a,l,PROT_READ+PROT_WRITE,
1343                 MAP_FIXED+MAP_PRIVATE+MAP_NORESERVE,-1,0);
1344 }
1345 EOT
1346 test_cxx "whether mmap() accepts MAP_NORESERVE" "yes" "no" ""
1347 AC_DEFINE_UNQUOTED(CMK_HAS_MMAP_NORESERVE, $pass, [whether mmap() accepts MAP_NORESERVE])
1348
1349 #### check if get_myaddress exists ####
1350 cat > $t <<EOT
1351 #include <rpc/rpc.h>
1352
1353 void foo(void *a) {
1354     get_myaddress((struct sockaddr_in*)a);
1355 }
1356 EOT
1357 test_cxx "whether has get_myaddress" "yes" "no" ""
1358 AC_DEFINE_UNQUOTED(CMK_HAS_GET_MYADDRESS, $pass, [whether has get_myaddress])
1359
1360 #### check if mprotect exists ####
1361 cat > $t <<EOT
1362 #include <stdio.h>
1363 #include <sys/mman.h>
1364
1365 void foo(void *a,int l,int fd) {
1366      void *pg = NULL;
1367      size_t pagesize = 4096;
1368      mprotect(pg, pagesize, PROT_READ | PROT_WRITE);
1369 }
1370 EOT
1371 test_cxx "whether has mprotect" "yes" "no" ""
1372 AC_DEFINE_UNQUOTED(CMK_HAS_MPROTECT, $pass, [whether has mprotect])
1373
1374 #### check if glibc backtrace exists ####
1375 cat > $t <<EOT
1376 #include "cmibacktrace.c"
1377
1378 int main() {
1379         int nLevels=1;
1380         void *stack;
1381         CmiBacktraceRecord(&stack,0,&nLevels);
1382         return 0;
1383 }
1384 EOT
1385 TRACE_LINK_FLAG="-rdynamic"
1386 test_link "whether glibc backtrace works" "yes" "no" "-DCMK_USE_BACKTRACE=1 $TRACE_LINK_FLAG"
1387 AC_DEFINE_UNQUOTED(CMK_USE_BACKTRACE, $pass, [whether glibc backtrace works])
1388
1389 if test $strictpass -eq 1
1390 then 
1391         add_flag 'CMK_LD="$CMK_LD '$TRACE_LINK_FLAG'"' "backtrace"
1392         add_flag 'CMK_LDXX="$CMK_LDXX '$TRACE_LINK_FLAG'"' "backtrace"
1393 fi
1394
1395 #### test sleep ####
1396 cat > $t <<EOT
1397 #include <unistd.h>
1398 int main() {
1399   sleep(1);
1400   return 0;
1401 }
1402 EOT
1403 test_cxx "whether has sleep " "yes" "no" ""
1404 AC_DEFINE_UNQUOTED(CMK_HAS_SLEEP, $pass, [whether has sleep])
1405
1406 #### test usleep ####
1407 cat > $t <<EOT
1408 #include <unistd.h>
1409 int main() {
1410   usleep(100);
1411   return 0;
1412 }
1413 EOT
1414 test_cxx "whether has usleep " "yes" "no" ""
1415 AC_DEFINE_UNQUOTED(CMK_HAS_USLEEP, $pass, [whether has usleep])
1416
1417 #### test personality() and ADDR_NO_RANDOMIZE ####
1418 # Only works on modern Linux systems
1419 cat > $t <<EOT
1420 #include <sys/personality.h>
1421 int main() {
1422     int orig_persona = personality(0xffffffff);
1423     personality(orig_persona | ADDR_NO_RANDOMIZE);
1424     return 0;
1425 }
1426 EOT
1427 test_cxx "whether personality() and ADDR_NO_RANDOMIZE exist" "yes" "no" ""
1428 AC_DEFINE_UNQUOTED(CMK_HAS_ADDR_NO_RANDOMIZE, $pass, [whether personality() and ADDR_NO_RANDOMIZE exist])
1429
1430
1431 #### test if has zlib ####
1432 # bproc doesnot like -lz in any case
1433 if test -z "$CMK_BPROC"
1434 then
1435
1436 cat > $t <<EOT
1437 #include <zlib.h>
1438 int main() { 
1439   gzFile f = gzopen("/tmp/x","r");
1440   gzprintf(f, "test...\n");
1441   gzclose(f);
1442   return 0;
1443 }
1444 EOT
1445 test_link "whether has zlib" "yes" "no" "-lz"
1446 AC_DEFINE_UNQUOTED(CMK_PROJECTIONS_USE_ZLIB, $pass, [whether has zlib])
1447 if test $pass -eq 1
1448 then 
1449         add_flag 'CMK_LIBZ="-lz"' "zlib"
1450 fi
1451
1452 fi
1453
1454 #### test if has elf.h ####
1455 cat > $t <<EOT
1456 #include <elf.h>
1457 typedef Elf32_Addr ELF_TYPE_Addr;
1458 int main() { 
1459 }
1460 EOT
1461 test_cxx "whether has elf.h " "yes" "no" ""
1462 AC_DEFINE_UNQUOTED([CMK_HAS_ELF_H], $pass, [whether has elf.h])
1463
1464 #### test if has Multiprocessing.h for apple ####
1465 cat > $t <<EOT
1466 #include <Carbon/Carbon.h>
1467 #include <Multiprocessing.h>
1468 int main() {
1469   int a = MPProcessorsScheduled();
1470 }
1471 EOT
1472 test_cxx "whether has Multiprocessing.h for Apple " "yes" "no" ""
1473 AC_DEFINE_UNQUOTED([CMK_HAS_MULTIPROCESSING_H], $pass, [whether has Multiprocessing.h])
1474
1475 #### test if "ntohl" is available ####
1476 cat > $t <<EOT
1477 #if defined(_WIN32) && ! defined(__CYGWIN__) || defined(__MINGW_H)
1478 #include <winsock.h>
1479 #else
1480 #include <netinet/in.h>
1481 #include <arpa/inet.h>
1482 #endif
1483
1484 int main() {
1485   int i = 100;
1486   i = ntohl(i);
1487   return 0;
1488 }
1489 EOT
1490 test_link "whether ntohl is available" "yes" "no" ""
1491 AC_DEFINE_UNQUOTED(CMK_HAS_NTOHL, $pass, [whether ntohl is available])
1492
1493 ### test for libjpeg ####
1494 cat > $t <<EOT
1495 #include <stdio.h>
1496 #include <stdlib.h>
1497 #include "jpeglib.h"
1498
1499 int main()
1500 {
1501   struct jpeg_compress_struct cinfo;
1502   jpeg_create_compress(&cinfo);
1503   return 0;
1504 }
1505 EOT
1506 test_link "whether has libjpeg" "yes" "no" "-ljpeg"
1507 AC_DEFINE_UNQUOTED(CMK_USE_LIBJPEG, $pass, [whether has libjpeg])
1508 if test $pass -eq 1
1509 then
1510         add_flag 'CMK_LIBJPEG="-ljpeg"' "libjpeg"
1511 fi
1512
1513 #### check if PAPI exists ####
1514 if test -n "$CMK_USE_PAPI"
1515 then
1516 cat > $t <<EOT
1517 #include <stdio.h>
1518 #include <papi.h>
1519                                                                                 
1520 int main() {
1521     if (PAPI_library_init(PAPI_VER_CURRENT) != PAPI_VER_CURRENT) return 1;
1522     return 0;
1523 }
1524 EOT
1525 test_link "whether PAPI exists" "yes" "no" "-lpapi"
1526 AC_DEFINE_UNQUOTED(CMK_HAS_COUNTER_PAPI, $pass, [whether PAPI exists])
1527 if test $pass -eq 1
1528 then 
1529         add_flag 'CMK_LIBS="$CMK_LIBS -lpapi"' "papi"
1530 fi
1531 fi
1532
1533 #### test if Python headers are installed ####
1534 PYTHON_VERSION=`python -V 2>&1 | awk {'print $2'} | awk -F. {'print $1"."$2'}`
1535 cat > $t <<EOT
1536 #include "python${PYTHON_VERSION}/Python.h"
1537 #include "python${PYTHON_VERSION}/compile.h"
1538 #include "python${PYTHON_VERSION}/eval.h"
1539 #include "python${PYTHON_VERSION}/node.h"
1540
1541 int main() {
1542     Py_Initialize();
1543     PyEval_InitThreads();
1544     struct _node* programNode = PyParser_SimpleParseString("return 1\n",Py_file_input);
1545     PyCodeObject *program = PyNode_Compile(programNode, "");
1546 }
1547 EOT
1548 test_link "whether Python is installed" "yes" "no" "-lpython$PYTHON_VERSION -lpthread -lutil -ldl"
1549 AC_DEFINE_UNQUOTED(CMK_HAS_PYTHON, $pass, [whether Python is installed])
1550 AC_DEFINE_UNQUOTED(CMK_PYTHON_VERSION, ${PYTHON_VERSION}, [Python version])
1551 if test $pass -eq 1
1552 then
1553         add_flag "CMK_BUILD_PYTHON=$PYTHON_VERSION" "python"
1554 fi
1555
1556 #### Pick up METIS if the user asks for it ####
1557
1558 AC_ARG_WITH([metis],
1559             [AS_HELP_STRING([--with-metis],
1560              [support the METIS graph partitioner and associated load balancer])],
1561             [],
1562             [with_metis=no])
1563
1564 WITH_METIS=no
1565 if test "$with_metis" != "no"
1566 then
1567   Echo "Compiling Charm with support for METIS"
1568   WITH_METIS=yes
1569   echo 'charm++: $(L)/libmoduleMetisLB.a $(L)/libmoduleTeamLB.a' >> $MAKEFILE_EXT
1570   add_flag 'CMK_LIBS="$CMK_LIBS -lmetis"' "libmetis"
1571   if test "$with_metis" != "yes"
1572   then
1573     add_flag "CMK_METIS=$with_metis" "Where to find METIS"
1574     add_flag 'CMK_LIBDIR="$CMK_LIBDIR -L$CMK_METIS"' "Library path for METIS"
1575     if test -r $with_metis/Lib/metis.h
1576     then
1577       add_flag 'CMK_INCDIR="$CMK_INCDIR -I$CMK_METIS/Lib"' "Include path for METIS 4"
1578     elif test -r $with_metis/../../include/metis.h
1579     then
1580       add_flag 'CMK_INCDIR="$CMK_INCDIR -I$CMK_METIS/../../include"' "Include path for METIS 5"
1581     else
1582       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."
1583       test_finish 1
1584     fi
1585   fi
1586 fi
1587
1588
1589 #### test if Cray node topology will work ####
1590 cat > $tc <<EOT
1591 #include <pmi.h>
1592
1593 int main() {
1594     int nid;
1595     PMI_Get_nid(0, &nid);
1596
1597     return 0;
1598 }
1599 EOT
1600 test_linkc "whether PMI_Get_nid exists" "yes" "no" ""
1601 AC_DEFINE_UNQUOTED(CMK_HAS_PMI_GET_NID, $pass, [whether PMI_Get_nid exists])
1602
1603 #### test if Cray mesh topology will work ####
1604 cat > $tc <<EOT
1605 #include <rca_lib.h>
1606
1607 int main() {
1608     rca_mesh_coord_t xyz;
1609     rca_get_meshcoord(0, &xyz);
1610
1611     return 0;
1612 }
1613 EOT
1614 test_linkc "whether Cray rca library is available" "yes" "no" "-lrca"
1615 AC_DEFINE_UNQUOTED(CMK_HAS_RCALIB, $pass, [whether Cray rca library is available])
1616
1617 #### test if it can build shared library ####
1618 cat > $t <<EOT
1619 #include "stdlib.h"
1620 extern int foo();
1621 int foo1() { 
1622   void * t= malloc(2);
1623   foo();
1624   return 0;
1625 }
1626 EOT
1627 test_linkso "whether can build shared library" "yes" "no" ""
1628 if test $pass -eq 0
1629 then 
1630         add_flag 'CMK_NO_BUILD_SHARED="true"' "build-shared"
1631 else
1632         BUILD_SHARED=1
1633         if test "$BUILD_MPI" = "1"
1634         then
1635 cat > $t <<EOT
1636 #include "stdlib.h"
1637 #include "mpi.h"
1638 extern int foo();
1639 int foo(int argc, char ** argv) {
1640   void * t= malloc(2);
1641   foo();
1642   MPI_Init(&argc, &argv);
1643   return 0;
1644 }
1645 EOT
1646                 test_linkso "whether can build shared library with MPI" "yes" "no" ""
1647                 BUILD_SHARED=$pass
1648         fi
1649         if test $BUILD_SHARED -eq 0
1650         then
1651                 add_flag 'CMK_NO_BUILD_SHARED="true"' "build-shared"
1652         fi
1653 fi
1654
1655 #### test the version number of bproc ####
1656 if test -n "$CMK_BPROC"
1657 then
1658 cat > $t <<EOT
1659 #include <stdio.h>
1660 #include <sys/bproc.h>
1661 int main()
1662 {
1663   struct bproc_version_t vers;
1664   bproc_version(&vers);
1665   printf("%s\n", vers.version_string);
1666 }
1667 EOT
1668 test_link "whether bproc compiles" "yes" "no" "-lbproc"
1669 if test $pass -eq 1
1670 then 
1671 AC_MSG_CHECKING("bproc version")
1672 bproc_ver=`./testlink`
1673 if test x$bproc_ver = x
1674 then
1675 test_result 0 "bproc version" "ERROR" ""
1676 test_finish 1
1677 else
1678 test_result 0 "bproc version" "$bproc_ver" ""
1679 fi
1680 bproc_ver=`echo $bproc_ver | cut -d'.' -f1`
1681 AC_DEFINE_UNQUOTED(CMK_BPROC_VERSION, $bproc_ver, [bproc version])
1682 fi
1683 fi
1684
1685 #### test the if command sync exists ####
1686 AC_CHECK_PROG(SYNC, sync, sync )
1687 if test -n "$SYNC"
1688 then
1689 AC_DEFINE_UNQUOTED(CMK_HAS_SYNC, 1, [sync program])
1690 fi
1691
1692 ################## Fortran #########################
1693
1694 #echo "set F77 compiler as: $CMK_CF77"
1695 AC_MSG_CHECKING("F77 compiler as")
1696 AC_MSG_RESULT("$CMK_CF77")
1697
1698 AC_MSG_CHECKING("whether Fortran 77 compiler works")
1699 ### test fortran 77 compiler ###
1700 cat > conftest.f <<EOF
1701       SUBROUTINE FOO_foo
1702       END
1703 EOF
1704 $CMK_CF77 -c conftest.f > /dev/null 2> /dev/null
1705 if test ! -r conftest.o
1706 then
1707   AC_MSG_RESULT("no")
1708 else
1709   AC_MSG_RESULT("yes")
1710 fi
1711
1712 ### test fortran 90 compiler ###
1713 #echo "set F90 compiler as: $CMK_CF90"
1714 AC_MSG_CHECKING("F90 compiler as")
1715 AC_MSG_RESULT("$CMK_CF90")
1716
1717 AC_MSG_CHECKING("whether Fortran 90 compiler works")
1718 cat > conftest2.f90 <<EOF
1719       SUBROUTINE FOO_foo
1720       END
1721 EOF
1722 $CMK_CF90 -c conftest2.f90 > /dev/null 2> /dev/null
1723 if test ! -r conftest2.o
1724 then
1725   AC_MSG_RESULT("no")
1726 else
1727   AC_MSG_RESULT("yes")
1728   mv -f conftest2.o conftest.o
1729   USE_FORTRAN90=1
1730 fi
1731
1732 ### check fortran name mangling
1733 AC_MSG_CHECKING(subroutine name used by Fortran 90 compiler)
1734
1735 if test -r conftest.o
1736 then
1737   AC_CACHE_VAL(_cv_fortran_postfix,
1738
1739   NAME=`$CMK_NM conftest.o | grep "foo_foo__"`
1740   if test "$NAME" != ""
1741   then
1742     _cv_fortran_postfix=TWOSCORE
1743     AC_DEFINE_UNQUOTED(CMK_FORTRAN_USES_TWOSCORE, 1, [TWOSCORE])
1744   else
1745     NAME=`$CMK_NM conftest.o | grep "foo_foo_"`
1746     if test "$NAME" != ""
1747     then
1748       _cv_fortran_postfix=ONESCORE
1749       AC_DEFINE_UNQUOTED(CMK_FORTRAN_USES_ONESCORE, 1, [ONESCORE])
1750     else
1751       NAME=`$CMK_NM conftest.o | grep "foo_foo"`
1752       if test "$NAME" != ""
1753       then
1754         _cv_fortran_postfix=NOSCORE
1755         AC_DEFINE_UNQUOTED(CMK_FORTRAN_USES_NOSCORE, 1, [NOSCORE])
1756       else
1757         NAME=`$CMK_NM conftest.o | grep "FOO_FOO"`
1758         if test "$NAME" != ""
1759         then
1760           _cv_fortran_postfix=ALLCAPS
1761           AC_DEFINE_UNQUOTED(CMK_FORTRAN_USES_ALLCAPS, 1, [ALLCAPS])
1762         else
1763           echo "#################################################"
1764           echo "FORTRAN compiler generated name not supported yet"
1765           echo "#################################################"
1766         fi
1767       fi
1768     fi
1769   fi
1770   rm -f conftest.f conftest.o
1771   )
1772   AC_MSG_RESULT($_cv_fortran_postfix)
1773 else
1774   AC_MSG_RESULT("Fortran compiler not working")
1775 fi
1776
1777 ### check module name ###
1778
1779 if test "$USE_FORTRAN90" = 1
1780 then
1781   cat > conftest.f90 <<EOF
1782       MODULE testmod
1783         interface 
1784           function fpup_issizing(p)
1785           INTEGER :: p
1786           logical fpup_issizing
1787           end function
1788         end interface
1789       END MODULE
1790 EOF
1791   AC_MSG_CHECKING(Fortran 90 mod name is capital)
1792   $CMK_CF90 -c conftest.f90 > /dev/null 2> /dev/null
1793   name=`ls TESTMOD.* 2>/dev/null`
1794   if test -n "$name"
1795   then
1796         AC_MSG_RESULT("yes")
1797         add_flag 'CMK_MOD_NAME_ALLCAPS=1' "mod name capital"
1798   else
1799         AC_MSG_RESULT("no")
1800         name=`ls testmod.* 2>/dev/null`
1801   fi
1802   if test -n "$name"
1803   then
1804         AC_MSG_CHECKING(Fortran 90 mod name extension)
1805         ext=`echo $name | sed -e 's/^[[^.]]*\.//'`
1806         add_flag 'CMK_MOD_EXT="'$ext'"' "mod name extension"
1807         AC_MSG_RESULT("$ext")
1808         /bin/rm -f $name
1809   fi
1810   /bin/rm -f conftest.f90
1811 fi
1812
1813 AC_OUTPUT(
1814 libs/ck-libs/ampi/ampiCC libs/ck-libs/ampi/ampirun,
1815
1816 chmod +x libs/ck-libs/ampi/ampiCC libs/ck-libs/ampi/ampirun
1817 )