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