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