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