properly compile ckcache.ci when int16 is supported.
[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=60401
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 # Figure out if the user has asked to enable the latest language standards
488 USER_ASKED_FOR_NEW_STD=`echo "$BUILDOPTS" | grep "-use-new-std" | wc -l`
489
490 # If the user has asked for the newer standards, check if the compilers know about them
491 if test $USER_ASKED_FOR_NEW_STD -ge 1
492 then
493
494 #### check if c compiler supports c11 compilation flags ####
495 cat > $tc <<EOT
496 #include <stdio.h>
497
498 int foo()
499 {
500   return 0;
501 }
502 EOT
503 test_cc "whether c compiler knows of the c11 standard" "ok" "no" "$CMK_ENABLE_C11"
504 AC_DEFINE_UNQUOTED(CMK_COMPILER_KNOWS_C11, $pass, [whether c compiler knows of the c11 standard] )
505 if test $pass -eq 1
506 then
507         # Record results for charmc's future use
508         add_flag 'CMK_COMPILER_KNOWS_C11="1"' "c11"
509         # For the rest of configure, append this to compilation flags
510         OPTS_CC="$CMK_ENABLE_C11 $OPTS"
511 fi
512
513 #### check if C++ compiler supports cpp11 compilation flags ####
514 cat > $t <<EOT
515 #include <iostream>
516
517 int foo()
518 {
519   return 0;
520 }
521 EOT
522 test_cxx "whether c++ compiler knows of the cpp11 standard" "ok" "no" "$CMK_ENABLE_CPP11"
523 AC_DEFINE_UNQUOTED(CMK_COMPILER_KNOWS_CPP11, $pass, [whether c++ compiler knows of the cpp11 standard] )
524 if test $pass -eq 1
525 then
526         # Record results for charmc's future use
527         add_flag 'CMK_COMPILER_KNOWS_CPP11="1"' "cpp11"
528         # For the rest of configure, append this to compilation flags
529         OPTS_CXX="$CMK_ENABLE_CPP11 $OPTS"
530 fi
531
532 fi # endif USER_ASKED_FOR_NEW_STD
533
534
535 # Perform the tests
536
537 AC_ARG_WITH([refnum-type],
538             [AS_HELP_STRING([--with-refnum-type=type],
539                             [size of the envelope refnum field])],
540             [], [with_refnum_type=no])
541
542 if test "$with_refnum_type" = "no" -o "$with_refnum_type" = "short"
543 then
544   Echo "Setting charm++ envelop refnum field to unsigned short"
545   AC_DEFINE_UNQUOTED(CMK_REFNUM_TYPE, unsigned short, [envelope refnum field set to UShort])
546 elif test "$with_refnum_type" = "int"
547 then
548   Echo "Setting charm++ envelop refnum field to unsigned int"
549   AC_DEFINE_UNQUOTED(CMK_REFNUM_TYPE, unsigned int, [envelope refnum field set to UInt])
550 else
551   Echo "Invalid size specified for refnum field"
552   test_finish 1
553 fi
554
555 #### Check if compiler if 64 bit ####
556 cat > $t <<EOT
557 #include <stdio.h>
558
559 int foo()
560 {
561 int x[[(int)(sizeof(void *) - 7)]]={0};
562 return x[[0]];
563 }
564 EOT
565 test_cxx "whether compiler generates code for 64-bit" "yes" "no" ""
566 AC_DEFINE_UNQUOTED(CMK_SIZET_64BIT, $strictpass, [whether size_t 64bit])
567 in64bit=$strictpass
568
569
570 #### check strings.h ####
571 cat > $t <<EOT
572 #include <strings.h>
573 int main() { 
574   char str[[8]];
575   bzero(str, 8);
576   return 0;
577 }
578 EOT
579 test_cxx "whether has strings.h " "yes" "no" ""
580 AC_DEFINE_UNQUOTED(CMK_HAS_STRINGS_H, $pass, [whether has strings.h])
581
582 #### test if has values.h ####
583 cat > $t <<EOT
584 #include <values.h>
585 int main() { 
586   double d = MAXDOUBLE;
587   return 0;
588 }
589 EOT
590 test_cxx "whether has values.h " "yes" "no" ""
591 AC_DEFINE_UNQUOTED(CMK_HAS_VALUES_H, $pass, [whether has values.h])
592
593 #### test if has stdint.h ####
594 cat > $t <<EOT
595 #include <stdint.h>
596 int main() { 
597   return 0;
598 }
599 EOT
600 test_cxx "whether has stdint.h " "yes" "no" ""
601 AC_DEFINE_UNQUOTED(CMK_HAS_STDINT_H, $pass, [whether has stdint.h])
602
603 #### test if has malloc.h ####
604 cat > $t <<EOT
605 #include <malloc.h>
606 int main() { 
607   return 0;
608 }
609 EOT
610 test_cxx "whether has malloc.h " "yes" "no" ""
611 AC_DEFINE_UNQUOTED(CMK_HAS_MALLOC_H, $pass, [whether has malloc.h])
612
613 #### test if has alloca.h ####
614 cat > $t <<EOT
615 #include <alloca.h>
616 int main() {
617   double *s=(double *)alloca(sizeof(double));
618   *s=1.0;
619   return 0;
620 }
621 EOT
622 test_cxx "whether has alloca.h " "yes" "no" ""
623 AC_DEFINE_UNQUOTED(CMK_HAS_ALLOCA_H, $pass, [whether has alloca.h])
624
625 #### test if has regex.h ####
626 cat > $t <<EOT
627 #include <regex.h>
628 int main() {
629   regex_t re;
630   regcomp(&re, ".*MOD.*", REG_EXTENDED|REG_NOSUB);
631   return 0;
632 }
633 EOT
634 test_cxx "whether has regex.h " "yes" "no" ""
635 AC_DEFINE_UNQUOTED(CMK_HAS_REGEX_H, $pass, [whether has regex.h])
636
637 #### Check bool ####
638 cat > $t <<EOT
639 #include <stdlib.h>
640 bool foo(void) { return true; }
641 EOT
642 test_cxx "whether C++ bool works" "ok" "no" ""
643 AC_DEFINE_UNQUOTED(CMK_BOOL_DEFINED, $pass, [whether C++ bool works])
644
645 #### Check long long ####
646 cat > $t <<EOT
647 #include <stdlib.h>
648 long long foo(void) { return 17; }
649 EOT
650 test_cxx "whether long long works" "yes" "no" ""
651 AC_DEFINE_UNQUOTED(CMK_LONG_LONG_DEFINED, $pass, [whether long long works])
652
653 #### Check __int64 ####
654 cat > $t <<EOT
655 #include <stdlib.h>
656 __int64 foo(void) { return 17; }
657 EOT
658 test_cxx "whether __int64 works" "yes" "no" ""
659 AC_DEFINE_UNQUOTED([CMK___int64_DEFINED], $pass, [whether __int64 works])
660
661 #### Check __int128 ####
662 cat > $t <<EOT
663 #include <stdlib.h>
664 int foo(void) {
665   __int128   a;
666   int x[[(int)(sizeof(__int128) - 15)]]={0};
667   return x[[0]];
668 }
669 EOT
670 test_cxx "whether __int128 (128-bit integer) works" "yes" "no" ""
671 AC_DEFINE_UNQUOTED([CMK___int128_DEFINED], $pass, [whether __int128 works])
672 if test $pass -eq 1
673 then
674   add_flag CMK_HAS_INT16=1
675 fi
676
677 #### Check __int128_t ####
678 cat > $t <<EOT
679 #include <stdlib.h>
680 int foo(void) {
681   __int128_t   a;
682   __uint128_t   b;
683   int x[[(int)(sizeof(__int128_t) - 15)]]={0};
684   return x[[0]];
685 }
686 EOT
687 test_cxx "whether __int128_t (128-bit integer) works" "yes" "no" ""
688 AC_DEFINE_UNQUOTED([CMK___int128_t_DEFINED], $pass, [whether __int128_t works])
689 if test $pass -eq 1
690 then
691   add_flag CMK_HAS_INT16=1
692 fi
693
694 #### Check long double ####
695 cat > $t <<EOT
696 #include <stdlib.h>
697 long double foo(void) { return 17.0; }
698 EOT
699 test_cxx "whether long double works" "yes" "no" ""
700 AC_DEFINE_UNQUOTED(CMK_LONG_DOUBLE_DEFINED, $strictpass, [whether long double works])
701
702 #### Check ucontext and FPU pointer ####
703 cat > $t <<EOT
704 #include <ucontext.h>
705 struct _libc_fpstate   fpstate;
706 fpregset_t *fp;
707 EOT
708 test_cxx "whether ucontext has FPU pointer" "yes" "no" ""
709 AC_DEFINE_UNQUOTED(CMK_CONTEXT_FPU_POINTER, $pass, [whether ucontext has pointer])
710
711 if test $pass -eq 1
712 then
713 cat > $t <<EOT
714 #include <ucontext.h>
715
716 int main()
717 {
718   ucontext_t context;
719   context.uc_mcontext.uc_regs = 0;
720 }
721 EOT
722 test_cxx "whether ucontext uses uc_regs" "yes" "no" ""
723 AC_DEFINE_UNQUOTED(CMK_CONTEXT_FPU_POINTER_UCREGS, $pass, [whether ucontext uses uc_regs union])
724 fi
725
726 cat > $t <<EOT
727 #include <ucontext.h>
728 vrregset_t *v_regs;
729 ucontext_t  uc;
730
731 void foo()
732 {
733   vrregset_t *ptr = uc.uc_mcontext.v_regs;
734 }
735 EOT
736 test_cxx "whether ucontext has pointer (v_regs) of vector type" "yes" "no" ""
737 AC_DEFINE_UNQUOTED(CMK_CONTEXT_V_REGS, $pass, [whether ucontext has pointer (v_regs) of vector type])
738
739 #### Check ucontext and FPU pointer ####
740 cat > $t <<EOT
741 #include <infiniband/verbs.h>
742 void test()
743 {
744     struct ibv_context    *context;
745     int ibPort;
746     struct ibv_port_attr attr;
747     if (ibv_query_port(context, ibPort, &attr) != 0) return;
748     if (attr.link_layer == IBV_LINK_LAYER_INFINIBAND)  return;
749 }
750 EOT
751 test_cxx "whether ibverbs ibv_port_attr has link_layer field" "yes" "no" ""
752 AC_DEFINE_UNQUOTED(CMK_IBV_PORT_ATTR_HAS_LINK_LAYER, $pass, [whether ibv_port_attr has link_layer field])
753
754
755 ###################### C++ Compiler Features #####################
756
757 #### check C inline ####
758 cat > $tc <<EOT
759 inline static int foo()
760 {
761   return 1;
762 }
763 EOT
764 test_cc "whether inline works in C" "yes" "no" ""
765 AC_DEFINE_UNQUOTED(CMK_C_INLINE, $strictpass, [whether C inline works in C])
766
767 #### check explicit ####
768 cat > $t <<EOT
769 #include <stdlib.h>
770 class er {
771  protected:
772    explicit er(unsigned int inType) {};
773 };
774 EOT
775 test_cxx "whether C++ class explicit keyword works" "ok" "no" ""
776 AC_DEFINE_UNQUOTED(CMK_EXPLICIT, $pass, [whether C++ class explicit keyword works])
777
778 #### check if signed char is same as char ####
779 cat > $t <<EOT
780 #include <stdlib.h>
781 class er {
782  protected:
783    void operator()(char &v,const char *desc=NULL) {};
784    void operator()(signed char &v,const char *desc=NULL) {};
785 };
786 EOT
787 test_cxx "whether C++ signed char and char differ" "yes" "no" ""
788 AC_DEFINE_UNQUOTED(CMK_SIGNEDCHAR_DIFF_CHAR, $pass, [whether C++ signed char and char differ])
789
790 #### check if C++ casts work ####
791 cat > $t <<EOT
792 int foo(float *t) {return *reinterpret_cast<int *>(t);}
793 EOT
794 test_cxx "whether C++ *_casts<> work" "ok" "no" ""
795 AC_DEFINE_UNQUOTED(CMK_CPP_CAST_LEGAL, $pass, [C++ *_casts<> work])
796 AC_DEFINE_UNQUOTED(CMK_CPP_CAST_ILLEGAL, $fail, [C++ *_casts<> does not work])
797
798
799 ### check if varsize array on stack ####
800 cat > $t <<EOT
801 #include <stdio.h>
802 void foo()
803 {
804   int size=10;
805   char arr[size];
806 }
807
808 EOT
809 test_cxx "whether C++ allows declaration of varsize array" "yes" "no" ""
810 AC_DEFINE_UNQUOTED(CMK_DECLARE_VARSIZE_ARRAY, $pass, [whether C++ allows declaration of variable sized array])
811
812 #### check if namespaces can be defined #####
813 cat > $t <<EOT
814 namespace foo {
815         int x;
816 }
817 EOT
818 test_cxx "whether namespaces work" "ok" "no" ""
819 AC_DEFINE_UNQUOTED(CMK_NAMESPACES_BROKEN, $fail, [whether namespaces work])
820
821
822 #### check if typeinfo exists and works #####
823 cat > $t <<EOT
824 #include <typeinfo>
825 const char *foo(void) {
826         int x;
827         return typeid(x).name();
828 }
829 EOT
830 test_cxx "whether typeinfo/typeid works" "ok" "no" ""
831 AC_DEFINE_UNQUOTED(CMK_HAS_TYPEINFO, $pass, [whether typeinfo/typeid works])
832
833 #### check if iterator_traits is defined #####
834 cat > $t <<EOT
835 #include <iterator>
836
837 template <typename T> // T models Input Iterator
838 typename std::iterator_traits<T>::value_type accumulate(T first, T last)
839 {
840       typename std::iterator_traits<T>::value_type result = 0;
841       while(first != last)
842             result += *first++;
843       return result;
844 }
845 EOT
846 test_cxx "whether std::iterator_traits is defined" "ok" "no" ""
847 AC_DEFINE_UNQUOTED(CMK_HAS_ITERATOR_TRAITS, $pass, [whether iterator_traits works])
848
849 #### check if std::distance is defined #####
850 cat > $t <<EOT
851 #include <vector>
852 #include <iterator>
853
854 int foo()
855 {
856   std::vector<int> tree;
857   return std::distance(tree.begin(), tree.end());
858 }
859 EOT
860 test_cxx "whether std::distance is defined" "ok" "no" ""
861 AC_DEFINE_UNQUOTED(CMK_HAS_STD_DISTANCE, $pass, [whether std::distance works])
862
863 #### check if std::inserter is defined #####
864 cat > $t <<EOT
865 #include <list>
866 #include <iterator>
867
868 void foo()
869 {
870   using namespace std;
871   list<int> L;
872   inserter ( L, L.end ( ) ) = 500;
873 }
874 EOT
875 test_cxx "whether std::inserter is defined" "ok" "no" ""
876 AC_DEFINE_UNQUOTED(CMK_HAS_STD_INSERTER, $pass, [whether std::inserter works])
877
878
879 ####### Check support for features added by the new C11 and CPP11 standards ########
880
881 #### check if std::unordered_map is defined #####
882 cat > $t <<EOT
883 #include <unordered_map>
884
885 int foo()
886 {
887   std::unordered_map<int,int> myhashtbl;
888   myhashtbl[[0]] = 42;
889   myhashtbl[[1234]] = 0;
890   return myhashtbl[[1234]];
891 }
892 EOT
893 test_cxx "whether std::unordered_map is defined" "ok" "no" ""
894 AC_DEFINE_UNQUOTED(CMK_HAS_STD_UNORDERED_MAP, $pass, [whether std::unordered_map works])
895
896
897 #### check if anon structs are permitted #####
898 cat > $t <<EOT
899 #include <iostream>
900 using std::cout;
901
902 struct idx
903 {
904     const static int dims = 3;
905     union
906     {
907         int data[[dims]];
908         struct { int x, y, z; };
909     };
910
911     idx(const int i=0, const int j=0, const int k=0): x(i), y(j), z(k) {}
912 };
913
914 int main()
915 {
916     cout<<"Hello World!\n";
917     idx myidx(1, 2, 3);
918     cout<< "idx = ("
919         << myidx.data[[0]] << ","
920         << myidx.data[[1]] << ","
921         << myidx.z << ")\n";
922     return (myidx.data[[0]] == 1 && myidx.y == 2 && myidx.data[[2]] == 3);
923 }
924 EOT
925 test_cxx "whether anon structs are permitted" "yes" "no" ""
926 AC_DEFINE_UNQUOTED(CMK_HAS_ANON_STRUCTS, $pass, [whether anon structs are permitted])
927
928
929 #### test if we can have multiple delete like this ####
930 cat > $t <<EOT
931 class foo {
932 public:
933   void operator delete(void*p){};
934   void operator delete(void*p,int*){};
935 };
936 EOT
937 test_cxx "whether operator delete can be overloaded in same class" "ok" "no" ""
938 AC_DEFINE_UNQUOTED(CMK_MULTIPLE_DELETE, $strictpass, [whether operator delete can be overloaded in same class])
939
940 #### test if offsetof exists ####
941 cat > $t <<EOT
942 #include <stddef.h>
943
944 struct FooType {
945         int f1;
946         int f2;
947         double f3;
948 };
949
950 void foo()
951 {
952   int off = offsetof(FooType, f2);
953 }
954 EOT
955 test_cxx "whether offsetof is defined" "yes" "no" ""
956 AC_DEFINE_UNQUOTED(CMK_HAS_OFFSETOF, $pass, [whether offsetof exists])
957
958 #### test if we can use gcc x86 assembly like this ####
959 cat > $t <<EOT
960 double foo(void)
961 {
962   unsigned long long int v=0;
963   int *lo=0+(int *)&v;
964   int *hi=1+(int *)&v;
965   __asm__ __volatile__(
966       "rdtsc; movl %%edx,%0; movl %%eax,%1"
967       : /* output  */ "=m" (*hi), "=m" (*lo)
968       : /* input */
969       : /* trashes */ "%edx", "%eax"
970   );
971   return v;
972 }
973 EOT
974 test_cxx "whether GCC x86 assembly works" "yes" "no" ""
975 AC_DEFINE_UNQUOTED(CMK_GCC_X86_ASM, $strictpass, [Allows gcc x86 assembly.])
976
977 #### test if we can use gcc x86 assembly like this ####
978 if test $strictpass = 1
979 then
980 cat > $t <<EOT
981 int foo(void)
982 {
983   int x;
984   asm("lock incl %0" :: "m" (x));
985   asm("lock decl %0" :: "m" (x));
986   return x;
987 }
988 EOT
989 test_cxx "whether GCC x86 assembly for atomic increment works" "yes" "no" ""
990 AC_DEFINE_UNQUOTED(CMK_GCC_X86_ASM_ATOMICINCREMENT, $strictpass, [Allows gcc x86 assembly for atomic increment.])
991 fi
992
993 #### test if we can use gcc IA64 assembly like this ####
994 cat > $t <<EOT
995 double foo(void)
996 {
997         unsigned long long int x;
998         __asm__ __volatile__("mov %0=ar.itc" : "=r"(x) :: "memory");
999         return x;
1000 }
1001 EOT
1002 test_cxx "whether GCC IA64 assembly works" "yes" "no" ""
1003 AC_DEFINE_UNQUOTED(CMK_GCC_IA64_ASM, $strictpass, [Allows gcc IA64 assembly.])
1004
1005
1006 #### test if we can use PPC assembly like this ####
1007 cat > $t <<EOT
1008 double foo(void)
1009 {
1010         unsigned long long int x;
1011         asm volatile("eieio" ::: "memory");
1012         return x;
1013 }
1014 EOT
1015 test_cxx "whether PPC assembly works" "yes" "no" ""
1016 AC_DEFINE_UNQUOTED(CMK_PPC_ASM, $strictpass, [Allows PPC assembly.])
1017
1018
1019
1020 #### test if we can use __thread ####
1021 cat > $t <<EOT
1022 __thread unsigned long long int x;
1023 static __thread  int y;
1024 void foo(void)
1025 {
1026         x = 1;
1027         y = 1;
1028 }
1029 EOT
1030 test_cxx "whether __thread (Thread Local Storage) is supported" "yes" "no" ""
1031 AC_DEFINE_UNQUOTED(CMK_HAS_TLS_VARIABLES, $strictpass, [Allows __thread.])
1032
1033 #### check __sync_add_and_fetch ####
1034 cat > $tc <<EOT
1035 #include <stdio.h>
1036 int main()
1037 {
1038   int t=1;
1039   __sync_add_and_fetch(&t, 1);
1040   return 1;
1041 }
1042 EOT
1043 test_linkc "whether synchronization primitives (__sync_add_and_fetch) works in C" "yes" "no" ""
1044 AC_DEFINE_UNQUOTED(CMK_C_SYNC_PRIMITIVES, $pass, [whether synchronization primitives works in C])
1045
1046 ### test if switching TLS register ###
1047 if test $in64bit = 1
1048 then
1049 cat > $t <<EOT
1050 #include <elf.h>
1051 #include <stdlib.h>
1052 #include <malloc.h>
1053
1054 void switchTLS() {
1055   Elf64_Addr m1, m2;
1056   asm volatile ("movq %%fs:0x0, %0\n\t"
1057                 "movq %1, %%fs:0x0\n\t"
1058                 : "=r"(m1)
1059                 : "r"(m2));
1060 }
1061 EOT
1062 test_cxx "whether switching TLS register (64-bit) is supported" "yes" "no" ""
1063 AC_DEFINE_UNQUOTED(CMK_TLS_SWITCHING64, $strictpass, [Allows switching TLS 64-bit.])
1064 else
1065 cat > $t <<EOT
1066 #include <elf.h>
1067 #include <stdlib.h>
1068 #include <malloc.h>
1069
1070 void switchTLS() {
1071   Elf32_Addr m1, m2;
1072   asm volatile ("movl %%gs:0x0, %0\n\t"
1073                 "movl %1, %%gs:0x0\n\t"
1074                 : "=r"(m1)
1075                 : "r"(m2));
1076 }
1077 EOT
1078 test_cxx "whether switching TLS register (32-bit) is supported" "yes" "no" ""
1079 AC_DEFINE_UNQUOTED(CMK_TLS_SWITCHING32, $strictpass, [Allows switching TLS in 32-bit.])
1080 fi
1081
1082 #### test if we can build MPI ####
1083 if test "$CMK_BUILD_MPI" = 1
1084 then
1085
1086 cat > $t <<EOT
1087 #include "mpi.h"
1088 int main(int argc, char **argv)
1089 {
1090   MPI_Init(&argc, &argv);
1091 }
1092 EOT
1093 mv -f ../include/mpi.h ../include/mpi.h.bak 2>/dev/null
1094 test_cxx "whether build on MPI" "yes" "no" ""
1095 AC_DEFINE_UNQUOTED(CMK_BUILD_ON_MPI, $strictpass, [build MPI.])
1096 BUILD_MPI=$strictpass
1097
1098 if test $BUILD_MPI -eq 0
1099 then
1100   echo "Error: Can not compile a MPI program"
1101   test_finish 1
1102 fi
1103
1104 if test $BUILD_MPI -eq 1 -a -z "$BGP_FLOOR"
1105 then
1106   test_link "whether need to specify MPI library" "no" "yes" ""
1107   if test $pass -ne 1
1108   then
1109     if test -z "$CMK_MPI_LIB"
1110     then
1111       test_link "whether -lmpich" "ok" "no" "-lmpich"
1112       if test $pass -eq 1
1113       then
1114         add_flag CMK_SYSLIBS='"$CMK_SYSLIBS -lmpich"' "mpi lib"
1115       else
1116         test_link "whether -lmpi" "ok" "no" "-lmpi"
1117         if test $pass -eq 1
1118         then
1119                 add_flag CMK_SYSLIBS='"$CMK_SYSLIBS -lmpi"' "mpi lib"
1120         else
1121                 echo "Error: can not find mpi library"
1122                 test_finish 1
1123         fi
1124       fi
1125     else
1126       add_flag CMK_SYSLIBS='"$CMK_SYSLIBS $CMK_MPI_LIB"' "mpi lib"
1127     fi
1128   fi
1129 fi
1130
1131 if test "$BUILD_MPI" = "1"
1132 then
1133 cat > $t <<EOT
1134 #include "mpi.h"
1135 int main(int argc, char **argv)
1136 {
1137   int thread_level, provided;
1138   thread_level = MPI_THREAD_FUNNELED;
1139   MPI_Init_thread(&argc, &argv, thread_level, &provided);
1140 }
1141 EOT
1142 test_cxx "whether MPI_Init_thread is supported" "yes" "no" ""
1143 AC_DEFINE_UNQUOTED(CMK_MPI_INIT_THREAD, $strictpass, [Allows MPI_Init_thread.])
1144 fi
1145 mv -f ../include/mpi.h.bak ../include/mpi.h 2>/dev/null
1146
1147 fi
1148
1149 ################### Syscalls and Libraries ###################
1150
1151 #### test for getrusage with RUSAGE_THREAD ###
1152 cat > $tc <<EOT
1153 #include <sys/time.h>
1154 #define __USE_GNU   1
1155 #include <sys/resource.h>
1156 int main() {
1157   struct rusage usage;
1158   getrusage(RUSAGE_THREAD, &usage);
1159   return 0;
1160 }
1161 EOT
1162 test_linkc "whether getrusage accepts RUSAGE_THREAD" "yes" "no" ""
1163 AC_DEFINE_UNQUOTED(CMK_HAS_RUSAGE_THREAD, $pass, [whether getrusage accepts RUSAGE_THREAD])
1164
1165 #### test for asctime ###
1166
1167 cat > $tc <<EOT
1168 #include <time.h>
1169 int main() {
1170   struct tm *local;
1171   time_t t;
1172   t = time(NULL);
1173   local = localtime(&t);
1174   asctime(local);
1175   return 0;
1176 }
1177 EOT
1178 test_linkc "whether has asctime" "yes" "no" ""
1179 AC_DEFINE_UNQUOTED(CMK_HAS_ASCTIME, $pass, [whether has asctime])
1180
1181 #### test for log2 ###
1182 cat > $t <<EOT
1183 #include <math.h>
1184 int main() {
1185   int i = log2(10);
1186   return 0;
1187 }
1188 EOT
1189 test_link "whether has log2" "yes" "no" ""
1190 AC_DEFINE_UNQUOTED(CMK_HAS_LOG2, $pass, [whether has log2])
1191
1192 #### test for sqrtf ###
1193 cat > $t <<EOT
1194 #include <math.h>
1195 int main() {
1196   float i = sqrtf((float)10.0);
1197   return 0;
1198 }
1199 EOT
1200 test_link "whether has sqrtf" "yes" "no" ""
1201 AC_DEFINE_UNQUOTED(CMK_HAS_SQRTF, $pass, [whether has sqrtf])
1202
1203 #### test for fabsf ###
1204 cat > $t <<EOT
1205 #include <math.h>
1206 int main() {
1207   float i = fabsf((float)10.0);
1208   return 0;
1209 }
1210 EOT
1211 test_link "whether has fabsf" "yes" "no" ""
1212 AC_DEFINE_UNQUOTED(CMK_HAS_FABSF, $pass, [whether has fabsf])
1213
1214 #### test for mkstemp ###
1215 cat > $t <<EOT
1216 #include <stdlib.h>
1217 #include <string.h>
1218 int main() {
1219   char fname[[128]];
1220   strcpy(fname, "/tmp/fdXXX.XXX");
1221   mkstemp(fname);
1222   return 0;
1223 }
1224 EOT
1225 test_link "whether has mkstemp" "yes" "no" ""
1226 AC_DEFINE_UNQUOTED(CMK_USE_MKSTEMP, $pass, [whether has mkstemp])
1227
1228 #### test for system ###
1229 cat > $t <<EOT
1230 #include <stdlib.h>
1231 int main() {
1232   system("/bin/ls");
1233   return 0;
1234 }
1235 EOT
1236 test_link "whether has system" "yes" "no" ""
1237 AC_DEFINE_UNQUOTED(CMK_HAS_SYSTEM, $pass, [whether has system])
1238
1239 #### test for sbrk ###
1240 cat > $t <<EOT
1241 #include <unistd.h>
1242 int main() {
1243   void *ptr  = sbrk(0); 
1244 }
1245 EOT
1246 test_link "whether has sbrk" "yes" "no" ""
1247 AC_DEFINE_UNQUOTED(CMK_HAS_SBRK, $pass, [whether has sbrk])
1248
1249 #### test for _setjmp/_longjmp ###
1250 cat > $t <<EOT
1251 #include <setjmp.h>
1252 int main() {
1253   jmp_buf buf;
1254   _setjmp(buf);
1255   _longjmp(buf, 0);
1256 }
1257 EOT
1258 test_link "whether has _setjmp/_longjmp" "yes" "no" ""
1259 AC_DEFINE_UNQUOTED(CMK_HAS_UNDERSCORE_SETJMP, $pass, [whether has _setjmp/_longjmp])
1260
1261 #### test for mstats ###
1262 cat > $t <<EOT
1263 #include <malloc.h>
1264 int main() {
1265   struct mstats ms = mstats();
1266 }
1267 EOT
1268 test_link "whether has mstats" "yes" "no" ""
1269 AC_DEFINE_UNQUOTED(CMK_HAS_MSTATS, $pass, [whether has mstats])
1270
1271 #### test for mallinfo ###
1272 cat > $t <<EOT
1273 #include <malloc.h>
1274 int main() {
1275   struct mallinfo mi = mallinfo();
1276 }
1277 EOT
1278 test_link "whether has mallinfo" "yes" "no" ""
1279 AC_DEFINE_UNQUOTED(CMK_HAS_MALLINFO, $pass, [whether has mallinfo])
1280
1281 #### test for popen ###
1282 cat > $t <<EOT
1283 #include <stdio.h>
1284 int main() {
1285   FILE *p = popen("/bin/ps", "r");
1286   pclose(p);
1287 }
1288 EOT
1289 test_link "whether has popen" "yes" "no" ""
1290 AC_DEFINE_UNQUOTED(CMK_HAS_POPEN, $pass, [whether has popen])
1291
1292 #### test for poll ###
1293 cat > $t <<EOT
1294 #include <poll.h>
1295 void foo(void) { 
1296   struct pollfd pos[[3]];
1297   poll(pos, 1, 1);
1298 }
1299 EOT
1300 test_cxx "whether has poll" "yes" "no" ""
1301 AC_DEFINE_UNQUOTED(CMK_USE_POLL, $pass, [whether the poll syscall exists])
1302
1303 #### check if getpagesize exists ####
1304 cat > $tc <<EOT
1305 #include <unistd.h>
1306
1307 int main(int argc, char **argv) {
1308     int s = getpagesize();
1309 }
1310 EOT
1311 test_linkc "whether has getpagesize" "yes" "no" ""
1312 AC_DEFINE_UNQUOTED(CMK_HAS_GETPAGESIZE, $pass, [whether getpagesize exists])
1313
1314 #### check if getpid exists ####
1315 cat > $tc <<EOT
1316 #include <sys/types.h>
1317 #include <unistd.h>
1318
1319 int main(int argc, char **argv) {
1320     pid_t pid = getpid();
1321 }
1322 EOT
1323 test_linkc "whether has getpid" "yes" "no" ""
1324 AC_DEFINE_UNQUOTED(CMK_HAS_GETPID, $pass, [whether getpid exists])
1325
1326 #### check if kill exists ####
1327 cat > $tc <<EOT
1328 #include <sys/types.h>
1329 #include <unistd.h>
1330 #include <signal.h>
1331
1332 int main(int argc, char**argv) 
1333 {
1334     pid_t pid = getpid();
1335     kill(pid, 9);
1336 }
1337 EOT
1338 test_linkc "whether has kill" "yes" "no" ""
1339 AC_DEFINE_UNQUOTED(CMK_HAS_KILL, $pass, [whether kill exists])
1340
1341 #### test for setpriority ###
1342 cat > $t <<EOT
1343 #include <sys/time.h>
1344 #include <sys/resource.h>
1345 void foo(void) { 
1346   setpriority(PRIO_PROCESS, 0, 0);
1347 }
1348 EOT
1349 test_cxx "whether has setpriority" "yes" "no" ""
1350 AC_DEFINE_UNQUOTED(CMK_HAS_SETPRIORITY, $pass, [whether the setpriority exists])
1351
1352 #### test for system ###
1353 cat > $t <<EOT
1354 #include "ckdll_system.C"
1355 EOT
1356 test_cxx "whether to use signal-safe system() " "yes" "no" ""
1357 AC_DEFINE_UNQUOTED(CMK_SIGSAFE_SYSTEM, $pass, [whether to use signal-safe system()])
1358
1359 ### test sched_setaffinity ####
1360 cat > $tc <<EOT
1361 #define _GNU_SOURCE
1362 #include <sched.h>
1363
1364 int main()
1365 {
1366   cpu_set_t cpuset;
1367   CPU_ZERO(&cpuset);
1368   CPU_SET(0, &cpuset);
1369   if (sched_setaffinity(0, sizeof(cpuset), &cpuset) < 0) {
1370     return -1;
1371   }
1372   return 0;
1373 }
1374 EOT
1375 test_linkc "whether sched_setaffinity call exists" "yes" "no" ""
1376 AC_DEFINE_UNQUOTED(CMK_HAS_SETAFFINITY, $pass, [whether the sched_setaffinity() exists])
1377
1378 ### test pthread_setaffinity_np ####
1379 cat > $tc <<EOT
1380 #include <stdlib.h>
1381 #include <stdio.h>
1382 #include <unistd.h>
1383 #include <pthread.h>
1384
1385 int main()
1386 {
1387   unsigned long mask = 0xffffffff;
1388   unsigned int len = sizeof(mask);
1389
1390   if (pthread_setaffinity_np(pthread_self(), len, &mask) < 0) {
1391     return -1;
1392   }
1393   return 0;
1394 }
1395 EOT
1396 test_linkc "whether pthread_setaffinity_np call exists" "yes" "no" "-lpthread"
1397 AC_DEFINE_UNQUOTED(CMK_HAS_PTHREAD_SETAFFINITY, $pass, [whether the pthread_setaffinity_np() exists])
1398
1399 ### test pthread_spin_lock ####
1400 cat > $tc <<EOT
1401 #include <stdlib.h>
1402 #include <stdio.h>
1403 #include <unistd.h>
1404 #include <pthread.h>
1405
1406 int main()
1407 {
1408   pthread_spinlock_t  lock;
1409
1410   pthread_spin_init(&lock, 0);
1411
1412   pthread_spin_lock(&lock);
1413
1414   return 0;
1415 }
1416 EOT
1417 test_linkc "whether pthread_spin_lock exists" "yes" "no" "-lpthread"
1418 AC_DEFINE_UNQUOTED(CMK_HAS_SPINLOCK, $pass, [whether the pthread_spin_lock exists])
1419
1420 ### check libnuma on Linux ####
1421 if test "$WITH_NUMA" = "yes"
1422 then
1423 cat > $tc <<EOT
1424 #include <stdlib.h>
1425 #include <stdio.h>
1426 #include <linux/mempolicy.h>
1427 #include <numaif.h>
1428 #include <numa.h>
1429
1430 int main()
1431 {
1432   if (get_mempolicy(NULL, NULL, 0, 0, 0) == 0) return 0;
1433   return -1;
1434 }
1435 EOT
1436 test_linkc "whether libnuma exists" "yes" "no" "-lnuma"
1437 AC_DEFINE_UNQUOTED(CMK_HAS_NUMACTRL, $pass, [whether NUMA control related functions exist])
1438 if test $pass -eq 1
1439 then
1440         add_flag 'CMK_SYSLIBS="$CMK_SYSLIBS -lnuma"' "libnuma"
1441 fi
1442 fi
1443
1444 #### check bindprocessors on AIX ####
1445 cat > $tc <<EOT
1446 #include <stdlib.h>
1447 #include <stdio.h>
1448 #include <unistd.h>
1449
1450 #include <sys/processor.h>
1451
1452 int main()
1453 {
1454   int retValue = 0;
1455   int pid;
1456   pid = getpid();
1457   if (bindprocessor(BINDPROCESS, pid, 0) == -1) return -1;
1458   return 0;
1459 }
1460 EOT
1461 test_linkc "whether bindprocessor call exists" "yes" "no" ""
1462 AC_DEFINE_UNQUOTED(CMK_HAS_BINDPROCESSOR, $pass, [whether the bindprocessor()
1463 exists])
1464
1465
1466 #### check if dlopen works ####
1467 skip_dl=0
1468 # for bproc, ignore -ldl
1469 test -n "$CMK_BPROC" && skip_dl=1
1470 test -n "$CMK_NO_DL" && skip_dl=1
1471 dl_opt='-ldl'
1472 #workaround for pgcc 4.0, -ldl crash linking, so use -Wl,-ldl to skip the prelinker.
1473 case "$CMK_CXX" in
1474 pgCC*) dl_opt='-Wl,-ldl' ;;
1475 esac
1476
1477 if test $skip_dl -eq 0 
1478 then
1479
1480 cat > $t <<EOT
1481 #include "ckdll_dlopen.C"
1482 int main() {
1483         CkDll dll("foo.so");
1484         return 0;
1485 }
1486 EOT
1487 test_link "whether dlopen links without $dl_opt" "yes" "no" ""
1488 noldl=$pass
1489 test_link "whether dlopen links with $dl_opt" "yes" "no" "$dl_opt"
1490 if test $pass -eq 1
1491 then 
1492 #dlopen requires -ldl: add it to our link line
1493         add_flag CMK_LIBS='"$CMK_LIBS '$dl_opt'"' "dlopen"
1494 fi
1495
1496 if test $pass -eq 1 -o $noldl -eq 1
1497 then
1498 # One version or another of dlopen worked: compile it in
1499         AC_DEFINE_UNQUOTED(CMK_DLL_USE_DLOPEN, 1, [dlopen])
1500 fi
1501
1502 ### test gethostname ####
1503 cat > $tc <<EOT
1504 #ifdef WIN32
1505 #include <Winsock2.h>
1506 #else
1507 #include <stdlib.h>
1508 #include <stdio.h>
1509 #include <unistd.h>
1510 #endif
1511
1512 int main()
1513 {
1514   char hostname[[1000]];
1515   gethostname(hostname, 999);
1516   return 0;
1517 }
1518 EOT
1519 test_linkc "whether gethostname call exists" "yes" "no" ""
1520 AC_DEFINE_UNQUOTED(CMK_HAS_GETHOSTNAME, $pass, [whether gethostname() exists])
1521
1522 #### check if getProcAddress works ####
1523 cat > $t <<EOT
1524 #include "ckdll_win32.C"
1525 EOT
1526 test_cxx "whether getProcAddress works" "yes" "no" ""
1527 AC_DEFINE_UNQUOTED(CMK_DLL_USE_WIN32, $pass, [whether getProcAddress works])
1528
1529 fi    # end of skip_dl
1530
1531 #### check if socklen_t exists ####
1532 cat > $t <<EOT
1533 #include <sys/types.h>
1534 #include <sys/socket.h>
1535
1536 void foo(void) {
1537         int i;
1538         socklen_t s=sizeof(i);
1539 }
1540 EOT
1541 test_cxx "whether has socklen_t" "yes" "no" ""
1542 AC_DEFINE_UNQUOTED(CMK_HAS_SOCKLEN, $pass, [whether has socklen_t])
1543
1544 ### test getifaddrs ####
1545 cat > $tc <<EOT
1546 #include <netinet/in.h> /* for sockaddr_in */
1547 #include <ifaddrs.h> /* for getifaddrs */
1548 #include <net/if.h> /* for IFF_RUNNING */
1549
1550 int main()
1551 {
1552   struct ifaddrs *interfaces=0;
1553   if( getifaddrs(&interfaces) == 0 ) {
1554         struct ifaddrs *interface;
1555         for( interface=interfaces; interface; interface=interface->ifa_next ) {
1556             if( (interface->ifa_flags & IFF_UP) && ! (interface->ifa_flags & IFF_LOOPBACK) ) {
1557                 const struct sockaddr_in *addr = (const struct sockaddr_in*)interface->ifa_addr;
1558                 if( addr && addr->sin_family==AF_INET ) {
1559                     break;
1560                 }
1561             }
1562         }
1563         freeifaddrs(interfaces);
1564   }
1565 }
1566 EOT
1567 test_linkc "whether getifaddrs call exists" "yes" "no" ""
1568 AC_DEFINE_UNQUOTED(CMK_HAS_GETIFADDRS, $pass, [whether getifaddrs() exists])
1569
1570 #### check if mmap exists ####
1571 cat > $t <<EOT
1572 #include <sys/types.h>
1573 #include <sys/mman.h>
1574
1575 void *foo(void *a,int l,int fd) {
1576         return mmap((caddr_t)a,l,PROT_READ+PROT_WRITE,
1577                  MAP_FIXED+MAP_PRIVATE,fd,0);
1578 }
1579 EOT
1580 test_cxx "whether the mmap() syscall exists" "yes" "no" ""
1581 AC_DEFINE_UNQUOTED(CMK_HAS_MMAP, $pass, [whether the mmap() syscall exists])
1582
1583 #### check if mmap accepts MAP_ANON ####
1584 cat > $t <<EOT
1585 #include <sys/types.h>
1586 #include <sys/mman.h>
1587
1588 void *foo(void *a,int l) {
1589         return mmap((caddr_t)a,l,PROT_READ+PROT_WRITE,
1590                 MAP_FIXED+MAP_PRIVATE+MAP_ANON,-1,0);
1591 }
1592 EOT
1593 test_cxx "whether mmap() accepts MAP_ANON" "yes" "no" ""
1594 AC_DEFINE_UNQUOTED(CMK_HAS_MMAP_ANON, $pass, [whether mmap() accepts MAP_ANON])
1595
1596 #### check if mmap accepts MAP_NORESERVE ####
1597 cat > $t <<EOT
1598 #include <sys/types.h>
1599 #include <sys/mman.h>
1600
1601 void *foo(void *a,int l) {
1602         return mmap((caddr_t)a,l,PROT_READ+PROT_WRITE,
1603                 MAP_FIXED+MAP_PRIVATE+MAP_NORESERVE,-1,0);
1604 }
1605 EOT
1606 test_cxx "whether mmap() accepts MAP_NORESERVE" "yes" "no" ""
1607 AC_DEFINE_UNQUOTED(CMK_HAS_MMAP_NORESERVE, $pass, [whether mmap() accepts MAP_NORESERVE])
1608
1609 #### check if get_myaddress exists ####
1610 cat > $t <<EOT
1611 #include <rpc/rpc.h>
1612
1613 void foo(void *a) {
1614     get_myaddress((struct sockaddr_in*)a);
1615 }
1616 EOT
1617 test_cxx "whether has get_myaddress" "yes" "no" ""
1618 AC_DEFINE_UNQUOTED(CMK_HAS_GET_MYADDRESS, $pass, [whether has get_myaddress])
1619
1620 #### check if mprotect exists ####
1621 cat > $t <<EOT
1622 #include <stdio.h>
1623 #include <sys/mman.h>
1624
1625 void foo(void *a,int l,int fd) {
1626      void *pg = NULL;
1627      size_t pagesize = 4096;
1628      mprotect(pg, pagesize, PROT_READ | PROT_WRITE);
1629 }
1630 EOT
1631 test_cxx "whether has mprotect" "yes" "no" ""
1632 AC_DEFINE_UNQUOTED(CMK_HAS_MPROTECT, $pass, [whether has mprotect])
1633
1634 #### check if glibc backtrace exists ####
1635 cat > $t <<EOT
1636 #include "cmibacktrace.c"
1637
1638 int main() {
1639         int nLevels=1;
1640         void *stack;
1641         CmiBacktraceRecord(&stack,0,&nLevels);
1642         return 0;
1643 }
1644 EOT
1645 TRACE_LINK_FLAG="-rdynamic"
1646 test_link "whether glibc backtrace works" "yes" "no" "-DCMK_USE_BACKTRACE=1 $TRACE_LINK_FLAG"
1647 AC_DEFINE_UNQUOTED(CMK_USE_BACKTRACE, $pass, [whether glibc backtrace works])
1648
1649 if test $strictpass -eq 1
1650 then 
1651         add_flag 'CMK_LD="$CMK_LD '$TRACE_LINK_FLAG'"' "backtrace"
1652         add_flag 'CMK_LDXX="$CMK_LDXX '$TRACE_LINK_FLAG'"' "backtrace"
1653 fi
1654
1655 #### test sleep ####
1656 cat > $t <<EOT
1657 #include <unistd.h>
1658 int main() {
1659   sleep(1);
1660   return 0;
1661 }
1662 EOT
1663 test_cxx "whether has sleep " "yes" "no" ""
1664 AC_DEFINE_UNQUOTED(CMK_HAS_SLEEP, $pass, [whether has sleep])
1665
1666 #### test usleep ####
1667 cat > $t <<EOT
1668 #include <unistd.h>
1669 int main() {
1670   usleep(100);
1671   return 0;
1672 }
1673 EOT
1674 test_cxx "whether has usleep " "yes" "no" ""
1675 AC_DEFINE_UNQUOTED(CMK_HAS_USLEEP, $pass, [whether has usleep])
1676
1677 #### test personality() and ADDR_NO_RANDOMIZE ####
1678 # Only works on modern Linux systems
1679 cat > $t <<EOT
1680 #include <sys/personality.h>
1681 int main() {
1682     int orig_persona = personality(0xffffffff);
1683     personality(orig_persona | ADDR_NO_RANDOMIZE);
1684     return 0;
1685 }
1686 EOT
1687 test_cxx "whether personality() and ADDR_NO_RANDOMIZE exist" "yes" "no" ""
1688 AC_DEFINE_UNQUOTED(CMK_HAS_ADDR_NO_RANDOMIZE, $pass, [whether personality() and ADDR_NO_RANDOMIZE exist])
1689
1690
1691 #### test if has zlib ####
1692 # bproc doesnot like -lz in any case
1693 if test -z "$CMK_BPROC"
1694 then
1695
1696 cat > $t <<EOT
1697 #include <zlib.h>
1698 int main() { 
1699   gzFile f = gzopen("/tmp/x","r");
1700   gzprintf(f, "test...\n");
1701   gzclose(f);
1702   return 0;
1703 }
1704 EOT
1705 test_link "whether has zlib" "yes" "no" "-lz"
1706 AC_DEFINE_UNQUOTED(CMK_PROJECTIONS_USE_ZLIB, $pass, [whether has zlib])
1707 if test $pass -eq 1
1708 then 
1709         add_flag 'CMK_LIBZ="-lz"' "zlib"
1710 fi
1711
1712 fi
1713
1714 #### test if has elf.h ####
1715 cat > $t <<EOT
1716 #include <elf.h>
1717 typedef Elf32_Addr ELF_TYPE_Addr;
1718 int main() { 
1719 }
1720 EOT
1721 test_cxx "whether has elf.h " "yes" "no" ""
1722 AC_DEFINE_UNQUOTED([CMK_HAS_ELF_H], $pass, [whether has elf.h])
1723
1724 #### test if has Multiprocessing.h for apple ####
1725 cat > $t <<EOT
1726 #include <Carbon/Carbon.h>
1727 #include <Multiprocessing.h>
1728 int main() {
1729   int a = MPProcessorsScheduled();
1730 }
1731 EOT
1732 test_cxx "whether has Multiprocessing.h for Apple " "yes" "no" ""
1733 AC_DEFINE_UNQUOTED([CMK_HAS_MULTIPROCESSING_H], $pass, [whether has Multiprocessing.h])
1734
1735 #### test if "ntohl" is available ####
1736 cat > $t <<EOT
1737 #if defined(_WIN32) && ! defined(__CYGWIN__) || defined(__MINGW_H)
1738 #include <winsock.h>
1739 #else
1740 #include <stdint.h>
1741 #include <arpa/inet.h>
1742 #include <netinet/in.h>
1743 #endif
1744
1745 int main() {
1746   int i = 100;
1747   i = ntohl(i);
1748   return 0;
1749 }
1750 EOT
1751 test_link "whether ntohl is available" "yes" "no" ""
1752 AC_DEFINE_UNQUOTED(CMK_HAS_NTOHL, $pass, [whether ntohl is available])
1753
1754 ### test for libjpeg ####
1755 cat > $t <<EOT
1756 #include <stdio.h>
1757 #include <stdlib.h>
1758 #include "jpeglib.h"
1759
1760 int main()
1761 {
1762   struct jpeg_compress_struct cinfo;
1763   jpeg_create_compress(&cinfo);
1764   return 0;
1765 }
1766 EOT
1767 test_link "whether has libjpeg" "yes" "no" "-ljpeg"
1768 AC_DEFINE_UNQUOTED(CMK_USE_LIBJPEG, $pass, [whether has libjpeg])
1769 if test $pass -eq 1
1770 then
1771         add_flag 'CMK_LIBJPEG="-ljpeg"' "libjpeg"
1772 fi
1773
1774 #### check if PAPI exists ####
1775 if test -n "$CMK_USE_PAPI"
1776 then
1777 cat > $t <<EOT
1778 #include <stdio.h>
1779 #include <papi.h>
1780                                                                                 
1781 int main() {
1782     if (PAPI_library_init(PAPI_VER_CURRENT) != PAPI_VER_CURRENT) return 1;
1783     return 0;
1784 }
1785 EOT
1786 test_link "whether PAPI exists" "yes" "no" "-lpapi"
1787 AC_DEFINE_UNQUOTED(CMK_HAS_COUNTER_PAPI, $pass, [whether PAPI exists])
1788 if test $pass -eq 1
1789 then 
1790         add_flag 'CMK_LIBS="$CMK_LIBS -lpapi"' "papi"
1791 fi
1792 fi
1793
1794 #### test if Python headers are installed ####
1795 PYTHON_VERSION=`python -V 2>&1 | awk {'print $2'} | awk -F. {'print $1"."$2'}`
1796 cat > $t <<EOT
1797 #include "python${PYTHON_VERSION}/Python.h"
1798 #include "python${PYTHON_VERSION}/compile.h"
1799 #include "python${PYTHON_VERSION}/eval.h"
1800 #include "python${PYTHON_VERSION}/node.h"
1801
1802 int main() {
1803     Py_Initialize();
1804     PyEval_InitThreads();
1805     struct _node* programNode = PyParser_SimpleParseString("return 1\n",Py_file_input);
1806     PyCodeObject *program = PyNode_Compile(programNode, "");
1807 }
1808 EOT
1809 test_link "whether Python is installed" "yes" "no" "-lpython$PYTHON_VERSION -lpthread -lutil -ldl"
1810 AC_DEFINE_UNQUOTED(CMK_HAS_PYTHON, $pass, [whether Python is installed])
1811 AC_DEFINE_UNQUOTED(CMK_PYTHON_VERSION, ${PYTHON_VERSION}, [Python version])
1812 if test $pass -eq 1
1813 then
1814         add_flag "CMK_BUILD_PYTHON=$PYTHON_VERSION" "python"
1815 fi
1816
1817 #### Pick up METIS if the user asks for it ####
1818
1819 AC_ARG_WITH([metis],
1820             [AS_HELP_STRING([--with-metis],
1821              [support the METIS graph partitioner and associated load balancer])],
1822             [],
1823             [with_metis=no])
1824
1825 WITH_METIS=no
1826 if test "$with_metis" != "no"
1827 then
1828   Echo "Compiling Charm with support for METIS"
1829   WITH_METIS=yes
1830   echo 'charm++: $(L)/libmoduleMetisLB.a $(L)/libmoduleTeamLB.a' >> $MAKEFILE_EXT
1831   add_flag 'CMK_LIBS="$CMK_LIBS -lmetis"' "libmetis"
1832   if test "$with_metis" != "yes"
1833   then
1834     add_flag "CMK_METIS=$with_metis" "Where to find METIS"
1835     add_flag 'CMK_LIBDIR="$CMK_LIBDIR -L$CMK_METIS"' "Library path for METIS"
1836     if test -r $with_metis/Lib/metis.h
1837     then
1838       add_flag 'CMK_INCDIR="$CMK_INCDIR -I$CMK_METIS/Lib"' "Include path for METIS 4"
1839     elif test -r $with_metis/../../include/metis.h
1840     then
1841       add_flag 'CMK_INCDIR="$CMK_INCDIR -I$CMK_METIS/../../include"' "Include path for METIS 5"
1842     else
1843       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."
1844       test_finish 1
1845     fi
1846   fi
1847 fi
1848
1849 ## Cray specific test
1850 if test "$CMK_BUILD_CRAY" = "1"
1851 then
1852
1853 #### test if Cray node topology will work ####
1854 cat > $tc <<EOT
1855 #include <pmi.h>
1856
1857 int main() {
1858     int nid;
1859     PMI_Get_nid(0, &nid);
1860
1861     return 0;
1862 }
1863 EOT
1864 test_linkc "whether PMI_Get_nid exists" "yes" "no" ""
1865 AC_DEFINE_UNQUOTED(CMK_HAS_PMI_GET_NID, $pass, [whether PMI_Get_nid exists])
1866
1867 #### test if Cray mesh topology will work ####
1868 cat > $tc <<EOT
1869 #include <rca_lib.h>
1870
1871 int main() {
1872     rca_mesh_coord_t xyz;
1873     rca_get_meshcoord(0, &xyz);
1874
1875     return 0;
1876 }
1877 EOT
1878 test_linkc "whether Cray rca library is available" "yes" "no" "-lrca"
1879 AC_DEFINE_UNQUOTED(CMK_HAS_RCALIB, $pass, [whether Cray rca library is available])
1880
1881 #### test if Cray mesh dimension query function will work ####
1882 cat > $tc <<EOT
1883 #include <rca_lib.h>
1884
1885 int main() {
1886     rca_mesh_coord_t xyz;
1887     rca_get_max_dimension(&xyz);
1888
1889     return 0;
1890 }
1891 EOT
1892 test_linkc "whether Cray rca_has get_max_dimension" "yes" "no" "-lrca"
1893 AC_DEFINE_UNQUOTED(CMK_HAS_RCA_MAX_DIMENSION, $pass, [whether Cray rca has rca_get_max_dimension])
1894
1895 #### query Cray machine max NID ####
1896
1897 cmd=`which xtprocadmin 2>/dev/null`
1898 if test -n "$cmd"
1899 then
1900     #maxnid=`xtprocadmin  | tail -1  | awk '{print $1}'`
1901     # workaround for hopper
1902     (export SHELL=/bin/csh; xtprocadmin >& t.$$)
1903     maxnid=`cat t.$$  | tail -1  | awk '{print $1}'`
1904     /bin/rm -f t.$$
1905     AC_MSG_CHECKING(Cray machine maxnid)
1906     AC_MSG_RESULT("$maxnid")
1907     if test -n "$maxnid"
1908     then
1909     AC_DEFINE_UNQUOTED(CMK_CRAY_MAXNID, $maxnid, [Cray MAXNID])
1910     fi
1911 fi
1912
1913 fi
1914
1915 #### test if it can build shared library ####
1916 cat > $t <<EOT
1917 #include "stdlib.h"
1918 extern int foo();
1919 int foo1() { 
1920   void * t= malloc(2);
1921   foo();
1922   return 0;
1923 }
1924 EOT
1925 test_linkso "whether can build shared library" "yes" "no" ""
1926 if test $pass -eq 0
1927 then 
1928         add_flag 'CMK_NO_BUILD_SHARED="true"' "build-shared"
1929 else
1930         BUILD_SHARED=1
1931         if test "$BUILD_MPI" = "1"
1932         then
1933 cat > $t <<EOT
1934 #include "stdlib.h"
1935 #include "mpi.h"
1936 extern int foo();
1937 int foo(int argc, char ** argv) {
1938   void * t= malloc(2);
1939   foo();
1940   MPI_Init(&argc, &argv);
1941   return 0;
1942 }
1943 EOT
1944                 test_linkso "whether can build shared library with MPI" "yes" "no" ""
1945                 BUILD_SHARED=$pass
1946         fi
1947         if test $BUILD_SHARED -eq 0
1948         then
1949                 add_flag 'CMK_NO_BUILD_SHARED="true"' "build-shared"
1950         fi
1951 fi
1952
1953 #### test the version number of bproc ####
1954 if test -n "$CMK_BPROC"
1955 then
1956 cat > $t <<EOT
1957 #include <stdio.h>
1958 #include <sys/bproc.h>
1959 int main()
1960 {
1961   struct bproc_version_t vers;
1962   bproc_version(&vers);
1963   printf("%s\n", vers.version_string);
1964 }
1965 EOT
1966 test_link "whether bproc compiles" "yes" "no" "-lbproc"
1967 if test $pass -eq 1
1968 then 
1969 AC_MSG_CHECKING("bproc version")
1970 bproc_ver=`./testlink`
1971 if test x$bproc_ver = x
1972 then
1973 test_result 0 "bproc version" "ERROR" ""
1974 test_finish 1
1975 else
1976 test_result 0 "bproc version" "$bproc_ver" ""
1977 fi
1978 bproc_ver=`echo $bproc_ver | cut -d'.' -f1`
1979 AC_DEFINE_UNQUOTED(CMK_BPROC_VERSION, $bproc_ver, [bproc version])
1980 fi
1981 fi
1982
1983 #### test the if command sync exists ####
1984 AC_CHECK_PROG(SYNC, sync, sync )
1985 if test -n "$SYNC"
1986 then
1987 AC_DEFINE_UNQUOTED(CMK_HAS_SYNC, 1, [sync program])
1988 fi
1989
1990 ################## Fortran #########################
1991
1992 #echo "set F77 compiler as: $CMK_CF77"
1993 AC_MSG_CHECKING("F77 compiler as")
1994 AC_MSG_RESULT("$CMK_CF77")
1995
1996 AC_MSG_CHECKING("whether Fortran 77 compiler works")
1997 ### test fortran 77 compiler ###
1998 cat > conftest.f <<EOF
1999       SUBROUTINE FOO_foo
2000       END
2001 EOF
2002 $CMK_CF77 -c conftest.f > /dev/null 2> /dev/null
2003 if test ! -r conftest.o
2004 then
2005   AC_MSG_RESULT("no")
2006 else
2007   AC_MSG_RESULT("yes")
2008 fi
2009
2010 ### test fortran 90 compiler ###
2011 #echo "set F90 compiler as: $CMK_CF90"
2012 AC_MSG_CHECKING("F90 compiler as")
2013 AC_MSG_RESULT("$CMK_CF90")
2014
2015 AC_MSG_CHECKING("whether Fortran 90 compiler works")
2016 cat > conftest2.f90 <<EOF
2017       SUBROUTINE FOO_foo
2018       END
2019 EOF
2020 $CMK_CF90 -c conftest2.f90 > /dev/null 2> /dev/null
2021 if test ! -r conftest2.o
2022 then
2023   AC_MSG_RESULT("no")
2024 else
2025   AC_MSG_RESULT("yes")
2026   mv -f conftest2.o conftest.o
2027   USE_FORTRAN90=1
2028 fi
2029
2030 ### check fortran name mangling
2031 AC_MSG_CHECKING(subroutine name used by Fortran 90 compiler)
2032
2033 if test -r conftest.o
2034 then
2035   AC_CACHE_VAL(_cv_fortran_postfix,
2036
2037   NAME=`$CMK_NM conftest.o | grep "foo_foo__"`
2038   if test "$NAME" != ""
2039   then
2040     _cv_fortran_postfix=TWOSCORE
2041     AC_DEFINE_UNQUOTED(CMK_FORTRAN_USES_TWOSCORE, 1, [TWOSCORE])
2042   else
2043     NAME=`$CMK_NM conftest.o | grep "foo_foo_"`
2044     if test "$NAME" != ""
2045     then
2046       _cv_fortran_postfix=ONESCORE
2047       AC_DEFINE_UNQUOTED(CMK_FORTRAN_USES_ONESCORE, 1, [ONESCORE])
2048     else
2049       NAME=`$CMK_NM conftest.o | grep "foo_foo"`
2050       if test "$NAME" != ""
2051       then
2052         _cv_fortran_postfix=NOSCORE
2053         AC_DEFINE_UNQUOTED(CMK_FORTRAN_USES_NOSCORE, 1, [NOSCORE])
2054       else
2055         NAME=`$CMK_NM conftest.o | grep "FOO_FOO"`
2056         if test "$NAME" != ""
2057         then
2058           _cv_fortran_postfix=ALLCAPS
2059           AC_DEFINE_UNQUOTED(CMK_FORTRAN_USES_ALLCAPS, 1, [ALLCAPS])
2060         else
2061           echo "#################################################"
2062           echo "FORTRAN compiler generated name not supported yet"
2063           echo "#################################################"
2064         fi
2065       fi
2066     fi
2067   fi
2068   rm -f conftest.f conftest.o
2069   )
2070   AC_MSG_RESULT($_cv_fortran_postfix)
2071 else
2072   AC_MSG_RESULT("Fortran compiler not working")
2073 fi
2074
2075 ### check module name ###
2076
2077 if test "$USE_FORTRAN90" = 1
2078 then
2079   cat > conftest.f90 <<EOF
2080       MODULE testmod
2081         interface 
2082           function fpup_issizing(p)
2083           INTEGER :: p
2084           logical fpup_issizing
2085           end function
2086         end interface
2087       END MODULE
2088 EOF
2089   AC_MSG_CHECKING(Fortran 90 mod name is capital)
2090   $CMK_CF90 -c conftest.f90 > /dev/null 2> /dev/null
2091   name=`ls TESTMOD.* 2>/dev/null`
2092   if test -n "$name"
2093   then
2094         AC_MSG_RESULT("yes")
2095         add_flag 'CMK_MOD_NAME_ALLCAPS=1' "mod name capital"
2096   else
2097         AC_MSG_RESULT("no")
2098         name=`ls testmod.* 2>/dev/null`
2099   fi
2100   if test -n "$name"
2101   then
2102         AC_MSG_CHECKING(Fortran 90 mod name extension)
2103         ext=`echo $name | sed -e 's/^[[^.]]*\.//'`
2104         add_flag 'CMK_MOD_EXT="'$ext'"' "mod name extension"
2105         AC_MSG_RESULT("$ext")
2106         /bin/rm -f $name
2107   fi
2108   /bin/rm -f conftest.f90
2109 fi
2110
2111 AC_OUTPUT(
2112 libs/ck-libs/ampi/ampiCC libs/ck-libs/ampi/ampirun,
2113
2114 chmod +x libs/ck-libs/ampi/ampiCC libs/ck-libs/ampi/ampirun
2115 )