updated
[charm.git] / src / scripts / configure.in
1
2 AC_INIT(./Makefile)
3
4 AC_CONFIG_HEADER(conv-autoconfig.h)
5
6 CHARMINC="."
7 test -r ./conv-config.sh && . ./conv-config.sh
8
9 # Decimal representation of Charm++ release line and API revision
10 # Increment the last 2 digits when making an API change
11 # Increase the first three after branching for a release
12 VERSION=60401
13 echo $VERSION > ../include/VERSION
14 AC_DEFINE_UNQUOTED([CHARM_VERSION], $VERSION, [Charm++ Release/API version number])
15
16 charmout="charmconfig.out"
17 /bin/rm -rf $charmout
18 MAKEFILE_EXT=Make.extlib
19
20 Echo() {
21         echo $* 
22         echo $* >> $charmout
23 }
24
25 # add into conv-mach-opt.sh
26 # add_flag $1 $2
27 # $2 is description
28 add_flag() {
29         key=`echo $1 | cut -d'=' -f1`
30         last=`grep "$key=" ../include/conv-mach-opt.sh 2>/dev/null | tail -1 | sed -e 's/ *#.*$//'`
31         skip=0
32         if test -n "$last" -a  "$last" = "$1" 
33         then
34           skip=1
35         fi
36         if test $skip = 0
37         then
38           cat >> ../include/conv-mach-opt.sh << EOT
39
40 $1   # Option added by configure script's $2 section
41 EOT
42         fi
43 }
44
45 # remove_flag $1
46 remove_flag() {
47      sed -e '/^'"$1"'=/d' ../include/conv-mach-opt.sh > tmp.$$
48      cp tmp.$$ ../include/conv-mach-opt.sh
49      /bin/rm -f tmp.$$
50 }
51
52
53 # enable/disable error checking
54 AC_ARG_ENABLE([error-checking],
55             [AS_HELP_STRING([--enable-error-checking],
56               [enable error checking])], ,
57             [enable_error_checking=yes])
58
59 if test "$enable_error_checking" = "no"
60 then
61   Echo "Error checking is disabled" 
62   AC_DEFINE_UNQUOTED(CMK_ERROR_CHECKING, 0, [disable error checking])
63 else
64   Echo "Error checking is enabled" 
65   AC_DEFINE_UNQUOTED(CMK_ERROR_CHECKING, 1, [enable error checking])
66 fi
67
68 # enable/disable statistics collection
69 AC_ARG_ENABLE([stats],
70             [AS_HELP_STRING([--enable-stats],
71               [enable statistics collection])], ,
72             [enable_stats=yes])
73
74 if test "$enable_stats" = "no"
75 then
76   Echo "Statistics collection is disabled" 
77   AC_DEFINE_UNQUOTED(CMK_WITH_STATS, 0, [disable statistics collection])
78 else
79   Echo "Statistics collection is enabled" 
80   AC_DEFINE_UNQUOTED(CMK_WITH_STATS, 1, [enable statistics collection])
81 fi
82
83 # check enable/disable
84 AC_ARG_ENABLE([tracing],
85             [AS_HELP_STRING([--enable-tracing],
86               [enable tracing modules])], ,
87             [enable_tracing=yes])
88
89 if test "$enable_tracing" = "no"
90 then
91   Echo "Charm tracing is disabled"
92   AC_DEFINE_UNQUOTED(CMK_TRACE_ENABLED, 0, [disable tracing])
93   add_flag CMK_TRACE_ENABLED=0
94 else
95   Echo "Charm tracing is enabled"
96   AC_DEFINE_UNQUOTED(CMK_TRACE_ENABLED, 1, [enable tracing])
97   add_flag CMK_TRACE_ENABLED=1
98 fi
99
100 AC_ARG_ENABLE([tracing-commthread],
101             [AS_HELP_STRING([--enable-tracing-commthread],
102               [enable tracing communication thread])], ,
103             [enable_tracing_commthread=yes])
104
105 if test "$enable_tracing_commthread" = "yes"
106 then
107   Echo "Charm tracing communication thread is enabled"
108   AC_DEFINE_UNQUOTED(CMK_SMP_TRACE_COMMTHREAD, 1, [enable tracing comm thread])
109 else
110   Echo "Charm tracing communication thread is disabled"
111   AC_DEFINE_UNQUOTED(CMK_SMP_TRACE_COMMTHREAD, 0, [disable tracing comm thread])
112 fi
113
114
115 AC_ARG_ENABLE([charmdebug],
116             [AS_HELP_STRING([--enable-charmdebug],
117               [enable charmDebug])], ,
118             [enable_charmdebug=yes])
119
120 if test "$enable_charmdebug" = "no"
121 then
122   Echo "CharmDebug is disabled" 
123   AC_DEFINE_UNQUOTED(CMK_CHARMDEBUG, 0, [disable charmdebug])
124   add_flag CMK_CHARMDEBUG=0
125 else
126   Echo "CharmDebug is enabled" 
127   AC_DEFINE_UNQUOTED(CMK_CHARMDEBUG, 1, [enable charmdebug])
128   add_flag CMK_CHARMDEBUG=1
129 fi
130
131 AC_ARG_ENABLE([replay],
132             [AS_HELP_STRING([--enable-replay],
133               [enable record/replay])],
134             [enable_replay=$enableval],
135             [enable_replay=yes])
136
137 if test "$enable_replay" = "no"
138 then
139   Echo "Charm record/replay is disabled"
140   AC_DEFINE_UNQUOTED(CMK_REPLAYSYSTEM, 0, [disable replay])
141 else
142   Echo "Charm record/replay is enabled"
143 fi
144
145 AC_ARG_ENABLE([ccs],
146             [AS_HELP_STRING([--enable-ccs],
147               [enable CCS])], ,
148             [enable_ccs=yes])
149
150 if test "$enable_ccs" = "no"
151 then
152   Echo "CCS is disabled" 
153   AC_DEFINE_UNQUOTED(CMK_CCS_AVAILABLE, 0, [disable ccs])
154 else
155   Echo "CCS is enabled" 
156   AC_DEFINE_UNQUOTED(CMK_CCS_AVAILABLE, 1, [enable ccs])
157 fi
158
159 AC_ARG_ENABLE([controlpoint],
160             [AS_HELP_STRING([--enable-controlpoint],
161               [enable control point])],
162             [enable_controlpoint=$enableval],
163             [enable_controlpoint=yes])
164
165 if test "$enable_controlpoint" = "yes"
166 then
167   Echo "Charm control point is enabled"
168   AC_DEFINE_UNQUOTED(CMK_WITH_CONTROLPOINT, 1, [enable controlpoint])
169 else
170   Echo "Charm control point is disabled"
171   AC_DEFINE_UNQUOTED(CMK_WITH_CONTROLPOINT, 0, [disable controlpoint])
172 fi
173
174 AC_ARG_WITH([numa],
175             [AS_HELP_STRING([--with-numa],
176               [support memory affinity with NUMA])],
177             [],
178             [with_numa=no])
179
180 WITH_NUMA=no
181 if test "$with_numa" = "yes"
182 then
183   Echo "Charm NUMA support is builtin"
184   WITH_NUMA=yes
185 fi
186
187 AC_ARG_WITH([lbtime-type],
188             [AS_HELP_STRING([--with-lbtime-type=type],
189                             [load balancing timer type])],
190             [], [with_lbtime_type=double])
191
192 if test "$with_lbtime_type" = "float" -o "$with_lbtime_type" = "double"
193 then
194   Echo "Setting load balancing timer type as '$with_lbtime_type'"
195   AC_DEFINE_UNQUOTED(CMK_LBTIME_TYPE, $with_lbtime_type, [Setting load balancing timer type])
196 else
197   Echo "Invalid type specified for load balancing timer type"
198   test_finish 1
199 fi
200
201 #clean up conv-mach-opt.sh
202 sed -e '/Option added by configure/d' ../include/conv-mach-opt.sh  | sed -e '/^$/d' > conv-mach-opt.sh.clean
203 cp -f conv-mach-opt.sh.clean   ../include/conv-mach-opt.sh
204 rm -f conv-mach-opt.sh.clean
205
206
207 #
208 AC_MSG_CHECKING(machine name)
209 version=`pwd | awk -F/ '{print $(NF-1)}'`
210 base_version=`cat .vdir`
211 AC_DEFINE_UNQUOTED(CMK_MACHINE_NAME, "$version",[machine name])
212 AC_MSG_RESULT($version)
213 AC_SUBST(base_version)
214
215 t="test.cpp"
216 tc="test.c"
217
218 # test result passed in $1
219 # If the test suceeded, print $3 and set "pass"/clear "fail"
220 # If the test failed, print $2 and clear "pass"/set "fail"
221 test_result() {
222         if test $1 -eq 0
223         then
224                 AC_MSG_RESULT("$3")
225                 pass="1"
226                 fail="0"
227         else
228                 AC_MSG_RESULT("$4")
229                 pass="0"
230                 fail="1"
231 # For debugging the configure script, just "export autoconf_debug=1"
232 #  to get this verbose data on any failed tests:
233                 if test ! -z "$autoconf_debug"
234                 then
235                         echo "------- test script for $2 failed:"
236                         cat out
237                         echo "------- the test program was:"
238                         cat $t
239                         echo "-------"
240                 fi
241         fi
242 }
243
244 # Test: tries to compile C file $t (described by $1).
245 #  If successful, prints $2 and sets $pass/clears $fail
246 #  If failure, prints $3 and sets $pass/clears $fail
247 #  additional arguments to c++ compiler are passed as $4
248 test_cc() {
249         AC_MSG_CHECKING("$1")
250         echo "### $1" >> $charmout
251         cat $tc >> $charmout
252         echo $CMK_CC -I../include -I. $CMK_LIBDIR $CMK_INCDIR $OPTS_CC $OPTS_LD -c $tc -o test.o $4 >> $charmout
253         $CMK_CC -I../include -I. $CMK_LIBDIR $CMK_INCDIR $OPTS_CC $OPTS_LD -c $tc -o test.o $4 > out 2>&1
254         test_result $? "$1" "$2" "$3"
255         strictpass=$pass
256         strictfail=$fail
257         if test $pass -eq 1
258         then 
259           if cat out | grep -i "warn" > /dev/null 2>&1
260           then 
261             strictpass="0" && strictfail="1"
262           fi
263         fi
264         cat out >> $charmout
265         /bin/rm -f out
266 }
267
268 # Test: tries to compile C++ file $t (described by $1).
269 #  If successful, prints $2 and sets $pass/clears $fail
270 #  If failure, prints $3 and sets $pass/clears $fail
271 #  additional arguments to c++ compiler are passed as $4
272 test_cxx() {
273         AC_MSG_CHECKING("$1")
274         echo "### $1" >> $charmout
275         cat $t >> $charmout
276         echo $CMK_CXX -I../include -I. $CMK_LIBDIR $CMK_INCDIR $OPTS_CXX $OPTS_LD -c $t -o test.o $4 >> $charmout
277         $CMK_CXX -I../include -I. $CMK_LIBDIR $CMK_INCDIR $OPTS_CXX $OPTS_LD -c $t -o test.o $4 > out 2>&1
278         test_result $? "$1" "$2" "$3"
279         strictpass=$pass
280         strictfail=$fail
281         if test $pass -eq 1
282         then 
283           if cat out | grep -i "warn" > /dev/null 2>&1
284           then 
285             strictpass="0" && strictfail="1"
286           fi
287         fi
288         cat out >> $charmout
289         /bin/rm -f out
290 }
291
292 # Testlink: tries to compile and link a C++ file $t (described by $1).
293 #  If successful, prints $2 and sets $pass/clears $fail
294 #  If failure, prints $3 and sets $pass/clears $fail
295 #  additional arguments to c++ compiler are passed as $4
296 test_link() {
297         AC_MSG_CHECKING("$1")
298         echo "### $1" >> $charmout
299         cat $t >> $charmout
300         echo $CMK_CXX -I../include -I. $CMK_INCDIR $OPTS_CXX -c $t -o test.o $4 >> $charmout
301         $CMK_CXX -I../include -I. $CMK_INCDIR $OPTS_CXX -c $t -o test.o $4 > out 2>&1
302         if test $? -ne 0
303         then
304           test_result 1 "$1" "$2" "$3"
305         else
306           echo $CMK_LDXX -o testlink test.o $CMK_LIBDIR $OPTS_LD $CMK_SYSLIBS $4 >> $charmout
307           $CMK_LDXX -o testlink test.o $CMK_LIBDIR $OPTS_LD $CMK_SYSLIBS $4 >> out 2>&1
308           ret=$?
309           test ! -x testlink && ret=1
310           test_result $ret "$1" "$2" "$3"
311         fi
312         strictpass=$pass
313         strictfail=$fail
314         if test $pass -eq 1
315         then 
316           if cat out | grep -i "warn" > /dev/null 2>&1
317           then 
318             strictpass="0" && strictfail="1"
319           fi
320         fi
321         cat out >> $charmout
322         /bin/rm -f out
323 }
324
325 # Testlinkc: tries to compile and link a C file $t (described by $1).
326 #  If successful, prints $2 and sets $pass/clears $fail
327 #  If failure, prints $3 and sets $pass/clears $fail
328 #  additional arguments to c++ compiler are passed as $4
329 test_linkc() {
330         AC_MSG_CHECKING("$1")
331         echo "### $1" >> $charmout
332         cat $tc >> $charmout
333         echo $CMK_CC -I../include -I. $CMK_INCDIR $OPTS_CC -c $tc -o test.o $4 >> $charmout
334         $CMK_CC -I../include -I. $CMK_INCDIR $OPTS_CC -c $tc -o test.o $4 > out 2>&1
335         if test $? -ne 0
336         then
337           test_result 1 "$1" "$2" "$3"
338         else
339           echo $CMK_LD -o testlink test.o $CMK_LIBDIR $OPTS_LD $CMK_SYSLIBS $4 >> $charmout
340           $CMK_LD -o testlink test.o $CMK_LIBDIR $OPTS_LD $CMK_SYSLIBS $4 >> out 2>&1
341           test_result $? "$1" "$2" "$3"
342         fi
343         strictpass=$pass
344         strictfail=$fail
345         if test $pass -eq 1
346         then 
347           if cat out | grep -i "warn" > /dev/null 2>&1
348           then 
349             strictpass="0" && strictfail="1"
350           fi
351         fi
352         cat out >> $charmout
353         /bin/rm -f out
354 }
355
356 # test_linkso $1 $2 $3 $4, where
357 # $1: debug msg
358 # $2: yes msg
359 # $3: no msg
360 # $4: extra link option
361 test_linkso() {
362         AC_MSG_CHECKING("$1")
363         echo $1 >> $charmout
364         cat $t >> $charmout
365         echo $CMK_CXX -I../include -I. $CMK_INCDIR $OPTS_CXX $CMK_PIC -c $t -o test.o $4 >> $charmout
366         $CMK_CXX -I../include -I. $CMK_INCDIR $OPTS_CXX -c $CMK_PIC $t -o test.o $4 > out 2>&1
367         if test $? = 1
368         then
369           test_result 1 "$1" "$2" "$3"
370         else
371           echo $CMK_LD -I../include -I. $CMK_LIBDIR $OPTS_LD $CMK_LD_SHARED test.o -o testlink.$CMK_SHARED_SUF $4 >> $charmout
372           $CMK_LD -I../include -I. $CMK_LIBDIR $OPTS_LD $CMK_LD_SHARED test.o -o testlink.$CMK_SHARED_SUF $4 > out 2>&1
373           test_result $? "$1" "$2" "$3"
374         fi
375         cat out >> $charmout
376         /bin/rm -f out testlink.$CMK_SHARED_SUF
377 }
378
379 test_finish() {
380         rm -f $t $tc testlink test.o    > /dev/null 2>&1
381         /bin/rm -f out
382         test $1 -eq 1 && echo "*** Please find detailed output in charmconfig.out ***"
383         exit $1
384 }
385
386 # detect certain architectures
387 if cat /proc/cpuinfo 2>/dev/null | grep 'POWER7'  > /dev/null
388 then
389   AC_DEFINE_UNQUOTED(CMK_POWER7, 1, [whether is power7])
390 fi
391
392 # detect OS
393 OSNAME=`uname -s`
394 if test $OSNAME = "Linux"
395 then
396   AC_DEFINE_UNQUOTED(CMK_OS_IS_LINUX, 1, [OS is Linux])
397 else
398   AC_DEFINE_UNQUOTED(CMK_OS_IS_LINUX, 0, [OS is Linux])
399 fi
400
401 # test cp -p
402 AC_MSG_CHECKING("cp command as")
403 CP="cp -p"
404 touch test_file
405 if ! $CP test_file test_file.cp 2>err
406 then
407   CP="cp"
408 fi
409 rm -f test_file test_file.cp
410 AC_MSG_RESULT($CP)
411 add_flag CP=\""$CP"\" "cp command"
412  
413
414 # try to decide the version of glibc
415 get_glibc_version() {
416 t=test.c
417 cat > $t <<EOT
418 #include <stdio.h>
419 #include <gnu/libc-version.h>
420 int main (void) { puts (gnu_get_libc_version ()); return 0; }
421 EOT
422 gcc -o gver test.c
423 GLIBCVERSION=`./gver`
424 /bin/rm -f $t gver
425 }
426
427 cat > $t <<EOT
428 #include <stdio.h>
429 void foo(void) {
430         printf("Hello, world!\n");
431 }
432 EOT
433 #echo "set C++ compiler as: $CMK_CXX $OPTS_CXX $OPTS"
434 AC_MSG_CHECKING("C++ compiler as")
435 AC_MSG_RESULT("$CMK_CXX $OPTS_CXX $OPTS")
436 test_cxx "whether C++ compiler works" "ok" "no" ""
437 if test $fail -eq 1
438 then
439         echo "Cannot compile C++ programs with $CMK_CXX"
440         echo " (check your charm++ version)"
441         test_finish 1
442 fi
443
444 cat > $t <<EOT
445 #include <stdio.h>
446 int main() {
447         printf("Hello, world!\n");
448         return 0;
449 }
450 EOT
451 #echo "set C++ linker as: $CMK_LDXX $OPTS_LDXX"
452 AC_MSG_CHECKING("C++ linker as")
453 AC_MSG_RESULT("$CMK_LDXX $OPTS_LDXX")
454 test_link "whether linker works" "ok" "no" ""
455 if test $fail -eq 1
456 then
457         echo "Cannot link C++ programs with $CMK_LDXX"
458         echo " (check your charm++ version)"
459         test_finish 1
460 fi
461
462 AC_MSG_CHECKING("Native C++ compiler as")
463 AC_MSG_RESULT("$CMK_NATIVE_CXX")
464 AC_MSG_CHECKING("Sequential C++ compiler as")
465 AC_MSG_RESULT("$CMK_SEQ_CXX")
466
467 if test "$base_version" = "net-linux" 
468 then
469   test_link "whether linker accept --allow-multiple-definition" "ok" "no" "-Wl,--allow-multiple-definition"
470   if test $pass -eq 1
471   then
472         remove_flag CMK_LDXX
473         add_flag CMK_LDXX='"$CMK_LDXX -Wl,--allow-multiple-definition"' "net-linux linker"
474   fi
475 fi
476
477 if echo "$base_version" | grep "linux" > /dev/null 2> /dev/null
478 then
479   test_link "whether compiler accept -fno-stack-protector" "ok" "no" "-fno-stack-protector"
480   if test $strictpass -eq 1
481   then
482         add_flag OPTS_CC='"$OPTS_CC -fno-stack-protector"' "linux compiler"
483         add_flag OPTS_CXX='"$OPTS_CXX -fno-stack-protector"' "linux compiler"
484   fi
485 fi
486
487 # Figure out if the user has asked to enable the latest language standards
488 USER_ASKED_FOR_NEW_STD=`echo "$BUILDOPTS" | grep "-use-new-std" | wc -l`
489
490 # If the user has asked for the newer standards, check if the compilers know about them
491 if test $USER_ASKED_FOR_NEW_STD -ge 1
492 then
493
494 #### check if c compiler supports c11 compilation flags ####
495 cat > $tc <<EOT
496 #include <stdio.h>
497
498 int foo()
499 {
500   return 0;
501 }
502 EOT
503 test_cc "whether c compiler knows of the c11 standard" "ok" "no" "$CMK_ENABLE_C11"
504 AC_DEFINE_UNQUOTED(CMK_COMPILER_KNOWS_C11, $pass, [whether c compiler knows of the c11 standard] )
505 if test $pass -eq 1
506 then
507         # Record results for charmc's future use
508         add_flag 'CMK_COMPILER_KNOWS_C11="1"' "c11"
509         # For the rest of configure, append this to compilation flags
510         OPTS_CC="$CMK_ENABLE_C11 $OPTS"
511 fi
512
513 #### check if C++ compiler supports cpp11 compilation flags ####
514 cat > $t <<EOT
515 #include <iostream>
516
517 int foo()
518 {
519   return 0;
520 }
521 EOT
522 test_cxx "whether c++ compiler knows of the cpp11 standard" "ok" "no" "$CMK_ENABLE_CPP11"
523 AC_DEFINE_UNQUOTED(CMK_COMPILER_KNOWS_CPP11, $pass, [whether c++ compiler knows of the cpp11 standard] )
524 if test $pass -eq 1
525 then
526         # Record results for charmc's future use
527         add_flag 'CMK_COMPILER_KNOWS_CPP11="1"' "cpp11"
528         # For the rest of configure, append this to compilation flags
529         OPTS_CXX="$CMK_ENABLE_CPP11 $OPTS"
530 fi
531
532 fi # endif USER_ASKED_FOR_NEW_STD
533
534
535 # Perform the tests
536
537 AC_ARG_WITH([refnum-type],
538             [AS_HELP_STRING([--with-refnum-type=type],
539                             [size of the envelope refnum field])],
540             [], [with_refnum_type=no])
541
542 if test "$with_refnum_type" = "no" -o "$with_refnum_type" = "short"
543 then
544   Echo "Setting charm++ envelop refnum field to unsigned short"
545   AC_DEFINE_UNQUOTED(CMK_REFNUM_TYPE, unsigned short, [envelope refnum field set to UShort])
546 elif test "$with_refnum_type" = "int"
547 then
548   Echo "Setting charm++ envelop refnum field to unsigned int"
549   AC_DEFINE_UNQUOTED(CMK_REFNUM_TYPE, unsigned int, [envelope refnum field set to UInt])
550 else
551   Echo "Invalid size specified for refnum field"
552   test_finish 1
553 fi
554
555 #### Check if compiler if 64 bit ####
556 cat > $t <<EOT
557 #include <stdio.h>
558
559 int foo()
560 {
561 int x[[(int)(sizeof(void *) - 7)]]={0};
562 return x[[0]];
563 }
564 EOT
565 test_cxx "whether compiler generates code for 64-bit" "yes" "no" ""
566 AC_DEFINE_UNQUOTED(CMK_SIZET_64BIT, $strictpass, [whether size_t 64bit])
567 in64bit=$strictpass
568
569
570 #### check strings.h ####
571 cat > $t <<EOT
572 #include <strings.h>
573 int main() { 
574   char str[[8]];
575   bzero(str, 8);
576   return 0;
577 }
578 EOT
579 test_cxx "whether has strings.h " "yes" "no" ""
580 AC_DEFINE_UNQUOTED(CMK_HAS_STRINGS_H, $pass, [whether has strings.h])
581
582 #### test if has values.h ####
583 cat > $t <<EOT
584 #include <values.h>
585 int main() { 
586   double d = MAXDOUBLE;
587   return 0;
588 }
589 EOT
590 test_cxx "whether has values.h " "yes" "no" ""
591 AC_DEFINE_UNQUOTED(CMK_HAS_VALUES_H, $pass, [whether has values.h])
592
593 #### test if has stdint.h ####
594 cat > $t <<EOT
595 #include <stdint.h>
596 int main() { 
597   return 0;
598 }
599 EOT
600 test_cxx "whether has stdint.h " "yes" "no" ""
601 AC_DEFINE_UNQUOTED(CMK_HAS_STDINT_H, $pass, [whether has stdint.h])
602
603 #### test if has malloc.h ####
604 cat > $t <<EOT
605 #include <malloc.h>
606 int main() { 
607   return 0;
608 }
609 EOT
610 test_cxx "whether has malloc.h " "yes" "no" ""
611 AC_DEFINE_UNQUOTED(CMK_HAS_MALLOC_H, $pass, [whether has malloc.h])
612
613 #### test if has alloca.h ####
614 cat > $t <<EOT
615 #include <alloca.h>
616 int main() {
617   double *s=(double *)alloca(sizeof(double));
618   *s=1.0;
619   return 0;
620 }
621 EOT
622 test_cxx "whether has alloca.h " "yes" "no" ""
623 AC_DEFINE_UNQUOTED(CMK_HAS_ALLOCA_H, $pass, [whether has alloca.h])
624
625 #### test if has regex.h ####
626 cat > $t <<EOT
627 #include <regex.h>
628 int main() {
629   regex_t re;
630   regcomp(&re, ".*MOD.*", REG_EXTENDED|REG_NOSUB);
631   return 0;
632 }
633 EOT
634 test_cxx "whether has regex.h " "yes" "no" ""
635 AC_DEFINE_UNQUOTED(CMK_HAS_REGEX_H, $pass, [whether has regex.h])
636
637 #### Check bool ####
638 cat > $t <<EOT
639 #include <stdlib.h>
640 bool foo(void) { return true; }
641 EOT
642 test_cxx "whether C++ bool works" "ok" "no" ""
643 AC_DEFINE_UNQUOTED(CMK_BOOL_DEFINED, $pass, [whether C++ bool works])
644
645 #### Check long long ####
646 cat > $t <<EOT
647 #include <stdlib.h>
648 long long foo(void) { return 17; }
649 EOT
650 test_cxx "whether long long works" "ok" "no" ""
651 AC_DEFINE_UNQUOTED(CMK_LONG_LONG_DEFINED, $pass, [whether long long works])
652
653 #### Check __int64 ####
654 cat > $t <<EOT
655 #include <stdlib.h>
656 __int64 foo(void) { return 17; }
657 EOT
658 test_cxx "whether __int64 works" "ok" "no" ""
659 AC_DEFINE_UNQUOTED([CMK___int64_DEFINED], $pass, [whether __int64 works])
660
661 #### Check long double ####
662 cat > $t <<EOT
663 #include <stdlib.h>
664 long double foo(void) { return 17.0; }
665 EOT
666 test_cxx "whether long double works" "ok" "no" ""
667 AC_DEFINE_UNQUOTED(CMK_LONG_DOUBLE_DEFINED, $strictpass, [whether long double works])
668
669 #### Check ucontext and FPU pointer ####
670 cat > $t <<EOT
671 #include <ucontext.h>
672 struct _libc_fpstate   fpstate;
673 fpregset_t *fp;
674 EOT
675 test_cxx "whether ucontext has FPU pointer" "yes" "no" ""
676 AC_DEFINE_UNQUOTED(CMK_CONTEXT_FPU_POINTER, $pass, [whether ucontext has pointer])
677
678 if test $pass -eq 1
679 then
680 cat > $t <<EOT
681 #include <ucontext.h>
682
683 int main()
684 {
685   ucontext_t context;
686   context.uc_mcontext.uc_regs = 0;
687 }
688 EOT
689 test_cxx "whether ucontext uses uc_regs" "yes" "no" ""
690 AC_DEFINE_UNQUOTED(CMK_CONTEXT_FPU_POINTER_UCREGS, $pass, [whether ucontext uses uc_regs union])
691 fi
692
693 cat > $t <<EOT
694 #include <ucontext.h>
695 vrregset_t *v_regs;
696 ucontext_t  uc;
697
698 void foo()
699 {
700   vrregset_t *ptr = uc.uc_mcontext.v_regs;
701 }
702 EOT
703 test_cxx "whether ucontext has pointer (v_regs) of vector type" "yes" "no" ""
704 AC_DEFINE_UNQUOTED(CMK_CONTEXT_V_REGS, $pass, [whether ucontext has pointer (v_regs) of vector type])
705
706 #### Check ucontext and FPU pointer ####
707 cat > $t <<EOT
708 #include <infiniband/verbs.h>
709 void test()
710 {
711     struct ibv_context    *context;
712     int ibPort;
713     struct ibv_port_attr attr;
714     if (ibv_query_port(context, ibPort, &attr) != 0) return;
715     if (attr.link_layer == IBV_LINK_LAYER_INFINIBAND)  return;
716 }
717 EOT
718 test_cxx "whether ibverbs ibv_port_attr has link_layer field" "yes" "no" ""
719 AC_DEFINE_UNQUOTED(CMK_IBV_PORT_ATTR_HAS_LINK_LAYER, $pass, [whether ibv_port_attr has link_layer field])
720
721
722 ###################### C++ Compiler Features #####################
723
724 #### check C inline ####
725 cat > $tc <<EOT
726 inline static int foo()
727 {
728   return 1;
729 }
730 EOT
731 test_cc "whether inline works in C" "yes" "no" ""
732 AC_DEFINE_UNQUOTED(CMK_C_INLINE, $strictpass, [whether C inline works in C])
733
734 #### check explicit ####
735 cat > $t <<EOT
736 #include <stdlib.h>
737 class er {
738  protected:
739    explicit er(unsigned int inType) {};
740 };
741 EOT
742 test_cxx "whether C++ class explicit keyword works" "ok" "no" ""
743 AC_DEFINE_UNQUOTED(CMK_EXPLICIT, $pass, [whether C++ class explicit keyword works])
744
745 #### check if signed char is same as char ####
746 cat > $t <<EOT
747 #include <stdlib.h>
748 class er {
749  protected:
750    void operator()(char &v,const char *desc=NULL) {};
751    void operator()(signed char &v,const char *desc=NULL) {};
752 };
753 EOT
754 test_cxx "whether C++ signed char and char differ" "yes" "no" ""
755 AC_DEFINE_UNQUOTED(CMK_SIGNEDCHAR_DIFF_CHAR, $pass, [whether C++ signed char and char differ])
756
757 #### check if C++ casts work ####
758 cat > $t <<EOT
759 int foo(float *t) {return *reinterpret_cast<int *>(t);}
760 EOT
761 test_cxx "whether C++ *_casts<> work" "ok" "no" ""
762 AC_DEFINE_UNQUOTED(CMK_CPP_CAST_LEGAL, $pass, [C++ *_casts<> work])
763 AC_DEFINE_UNQUOTED(CMK_CPP_CAST_ILLEGAL, $fail, [C++ *_casts<> does not work])
764
765
766 ### check if varsize array on stack ####
767 cat > $t <<EOT
768 #include <stdio.h>
769 void foo()
770 {
771   int size=10;
772   char arr[size];
773 }
774
775 EOT
776 test_cxx "whether C++ allows declaration of varsize array" "yes" "no" ""
777 AC_DEFINE_UNQUOTED(CMK_DECLARE_VARSIZE_ARRAY, $pass, [whether C++ allows declaration of variable sized array])
778
779 #### check if namespaces can be defined #####
780 cat > $t <<EOT
781 namespace foo {
782         int x;
783 }
784 EOT
785 test_cxx "whether namespaces work" "ok" "no" ""
786 AC_DEFINE_UNQUOTED(CMK_NAMESPACES_BROKEN, $fail, [whether namespaces work])
787
788
789 #### check if typeinfo exists and works #####
790 cat > $t <<EOT
791 #include <typeinfo>
792 const char *foo(void) {
793         int x;
794         return typeid(x).name();
795 }
796 EOT
797 test_cxx "whether typeinfo/typeid works" "ok" "no" ""
798 AC_DEFINE_UNQUOTED(CMK_HAS_TYPEINFO, $pass, [whether typeinfo/typeid works])
799
800 #### check if iterator_traits is defined #####
801 cat > $t <<EOT
802 #include <iterator>
803
804 template <typename T> // T models Input Iterator
805 typename std::iterator_traits<T>::value_type accumulate(T first, T last)
806 {
807       typename std::iterator_traits<T>::value_type result = 0;
808       while(first != last)
809             result += *first++;
810       return result;
811 }
812 EOT
813 test_cxx "whether std::iterator_traits is defined" "ok" "no" ""
814 AC_DEFINE_UNQUOTED(CMK_HAS_ITERATOR_TRAITS, $pass, [whether iterator_traits works])
815
816 #### check if std::distance is defined #####
817 cat > $t <<EOT
818 #include <vector>
819 #include <iterator>
820
821 int foo()
822 {
823   std::vector<int> tree;
824   return std::distance(tree.begin(), tree.end());
825 }
826 EOT
827 test_cxx "whether std::distance is defined" "ok" "no" ""
828 AC_DEFINE_UNQUOTED(CMK_HAS_STD_DISTANCE, $pass, [whether std::distance works])
829
830 #### check if std::inserter is defined #####
831 cat > $t <<EOT
832 #include <list>
833 #include <iterator>
834
835 void foo()
836 {
837   using namespace std;
838   list<int> L;
839   inserter ( L, L.end ( ) ) = 500;
840 }
841 EOT
842 test_cxx "whether std::inserter is defined" "ok" "no" ""
843 AC_DEFINE_UNQUOTED(CMK_HAS_STD_INSERTER, $pass, [whether std::inserter works])
844
845
846 ####### Check support for features added by the new C11 and CPP11 standards ########
847
848 #### check if std::unordered_map is defined #####
849 cat > $t <<EOT
850 #include <unordered_map>
851
852 int foo()
853 {
854   std::unordered_map<int,int> myhashtbl;
855   myhashtbl[[0]] = 42;
856   myhashtbl[[1234]] = 0;
857   return myhashtbl[[1234]];
858 }
859 EOT
860 test_cxx "whether std::unordered_map is defined" "ok" "no" ""
861 AC_DEFINE_UNQUOTED(CMK_HAS_STD_UNORDERED_MAP, $pass, [whether std::unordered_map works])
862
863
864 #### test if we can have multiple delete like this ####
865 cat > $t <<EOT
866 class foo {
867 public:
868   void operator delete(void*p){};
869   void operator delete(void*p,int*){};
870 };
871 EOT
872 test_cxx "whether operator delete can be overloaded in same class" "ok" "no" ""
873 AC_DEFINE_UNQUOTED(CMK_MULTIPLE_DELETE, $strictpass, [whether operator delete can be overloaded in same class])
874
875 #### test if offsetof exists ####
876 cat > $t <<EOT
877 #include <stddef.h>
878
879 struct FooType {
880         int f1;
881         int f2;
882         double f3;
883 };
884
885 void foo()
886 {
887   int off = offsetof(FooType, f2);
888 }
889 EOT
890 test_cxx "whether offsetof is defined" "yes" "no" ""
891 AC_DEFINE_UNQUOTED(CMK_HAS_OFFSETOF, $pass, [whether offsetof exists])
892
893 #### test if we can use gcc x86 assembly like this ####
894 cat > $t <<EOT
895 double foo(void)
896 {
897   unsigned long long int v;
898   int *lo=0+(int *)&v;
899   int *hi=1+(int *)&v;
900   __asm__ __volatile__(
901       "rdtsc; movl %%edx,%0; movl %%eax,%1"
902       : /* output  */ "=m" (*hi), "=m" (*lo)
903       : /* input */
904       : /* trashes */ "%edx", "%eax"
905   );
906   return v;
907 }
908 EOT
909 test_cxx "whether GCC x86 assembly works" "yes" "no" ""
910 AC_DEFINE_UNQUOTED(CMK_GCC_X86_ASM, $strictpass, [Allows gcc x86 assembly.])
911
912 #### test if we can use gcc x86 assembly like this ####
913 if test $strictpass = 1
914 then
915 cat > $t <<EOT
916 int foo(void)
917 {
918   int x;
919   asm("lock incl %0" :: "m" (x));
920   asm("lock decl %0" :: "m" (x));
921   return x;
922 }
923 EOT
924 test_cxx "whether GCC x86 assembly for atomic increment works" "yes" "no" ""
925 AC_DEFINE_UNQUOTED(CMK_GCC_X86_ASM_ATOMICINCREMENT, $strictpass, [Allows gcc x86 assembly for atomic increment.])
926 fi
927
928 #### test if we can use gcc IA64 assembly like this ####
929 cat > $t <<EOT
930 double foo(void)
931 {
932         unsigned long long int x;
933         __asm__ __volatile__("mov %0=ar.itc" : "=r"(x) :: "memory");
934         return x;
935 }
936 EOT
937 test_cxx "whether GCC IA64 assembly works" "yes" "no" ""
938 AC_DEFINE_UNQUOTED(CMK_GCC_IA64_ASM, $strictpass, [Allows gcc IA64 assembly.])
939
940
941 #### test if we can use PPC assembly like this ####
942 cat > $t <<EOT
943 double foo(void)
944 {
945         unsigned long long int x;
946         asm volatile("eieio" ::: "memory");
947         return x;
948 }
949 EOT
950 test_cxx "whether PPC assembly works" "yes" "no" ""
951 AC_DEFINE_UNQUOTED(CMK_PPC_ASM, $strictpass, [Allows PPC assembly.])
952
953
954
955 #### test if we can use __thread ####
956 cat > $t <<EOT
957 __thread unsigned long long int x;
958 static __thread  int y;
959 void foo(void)
960 {
961         x = 1;
962         y = 1;
963 }
964 EOT
965 test_cxx "whether __thread (Thread Local Storage) is supported" "yes" "no" ""
966 AC_DEFINE_UNQUOTED(CMK_HAS_TLS_VARIABLES, $strictpass, [Allows __thread.])
967
968 #### check __sync_add_and_fetch ####
969 cat > $tc <<EOT
970 #include <stdio.h>
971 int main()
972 {
973   int t=1;
974   __sync_add_and_fetch(&t, 1);
975   return 1;
976 }
977 EOT
978 test_linkc "whether synchronization primitives (__sync_add_and_fetch) works in C" "yes" "no" ""
979 AC_DEFINE_UNQUOTED(CMK_C_SYNC_PRIMITIVES, $pass, [whether synchronization primitives works in C])
980
981 ### test if switching TLS register ###
982 if test $in64bit = 1
983 then
984 cat > $t <<EOT
985 #include <elf.h>
986 #include <stdlib.h>
987 #include <malloc.h>
988
989 void switchTLS() {
990   Elf64_Addr m1, m2;
991   asm volatile ("movq %%fs:0x0, %0\n\t"
992                 "movq %1, %%fs:0x0\n\t"
993                 : "=r"(m1)
994                 : "r"(m2));
995 }
996 EOT
997 test_cxx "whether switching TLS register (64-bit) is supported" "yes" "no" ""
998 AC_DEFINE_UNQUOTED(CMK_TLS_SWITCHING64, $strictpass, [Allows switching TLS 64-bit.])
999 else
1000 cat > $t <<EOT
1001 #include <elf.h>
1002 #include <stdlib.h>
1003 #include <malloc.h>
1004
1005 void switchTLS() {
1006   Elf32_Addr m1, m2;
1007   asm volatile ("movl %%gs:0x0, %0\n\t"
1008                 "movl %1, %%gs:0x0\n\t"
1009                 : "=r"(m1)
1010                 : "r"(m2));
1011 }
1012 EOT
1013 test_cxx "whether switching TLS register (32-bit) is supported" "yes" "no" ""
1014 AC_DEFINE_UNQUOTED(CMK_TLS_SWITCHING32, $strictpass, [Allows switching TLS in 32-bit.])
1015 fi
1016
1017 #### test if we can build MPI ####
1018 if test "$CMK_BUILD_MPI" = 1
1019 then
1020
1021 cat > $t <<EOT
1022 #include "mpi.h"
1023 int main(int argc, char **argv)
1024 {
1025   MPI_Init(&argc, &argv);
1026 }
1027 EOT
1028 mv -f ../include/mpi.h ../include/mpi.h.bak 2>/dev/null
1029 test_cxx "whether build on MPI" "yes" "no" ""
1030 AC_DEFINE_UNQUOTED(CMK_BUILD_ON_MPI, $strictpass, [build MPI.])
1031 BUILD_MPI=$strictpass
1032
1033 if test $BUILD_MPI -eq 0
1034 then
1035   echo "Error: Can not compile a MPI program"
1036   test_finish 1
1037 fi
1038
1039 if test $BUILD_MPI -eq 1 -a -z "$BGP_FLOOR"
1040 then
1041   test_link "whether need to specify MPI library" "no" "yes" ""
1042   if test $pass -ne 1
1043   then
1044     if test -z "$CMK_MPI_LIB"
1045     then
1046       test_link "whether -lmpich" "ok" "no" "-lmpich"
1047       if test $pass -eq 1
1048       then
1049         add_flag CMK_SYSLIBS='"$CMK_SYSLIBS -lmpich"' "mpi lib"
1050       else
1051         test_link "whether -lmpi" "ok" "no" "-lmpi"
1052         if test $pass -eq 1
1053         then
1054                 add_flag CMK_SYSLIBS='"$CMK_SYSLIBS -lmpi"' "mpi lib"
1055         else
1056                 echo "Error: can not find mpi library"
1057                 test_finish 1
1058         fi
1059       fi
1060     else
1061       add_flag CMK_SYSLIBS='"$CMK_SYSLIBS $CMK_MPI_LIB"' "mpi lib"
1062     fi
1063   fi
1064 fi
1065
1066 if test "$BUILD_MPI" = "1"
1067 then
1068 cat > $t <<EOT
1069 #include "mpi.h"
1070 int main(int argc, char **argv)
1071 {
1072   int thread_level, provided;
1073   thread_level = MPI_THREAD_FUNNELED;
1074   MPI_Init_thread(&argc, &argv, thread_level, &provided);
1075 }
1076 EOT
1077 test_cxx "whether MPI_Init_thread is supported" "yes" "no" ""
1078 AC_DEFINE_UNQUOTED(CMK_MPI_INIT_THREAD, $strictpass, [Allows MPI_Init_thread.])
1079 fi
1080 mv -f ../include/mpi.h.bak ../include/mpi.h 2>/dev/null
1081
1082 fi
1083
1084 ################### Syscalls and Libraries ###################
1085
1086 #### test for getrusage with RUSAGE_THREAD ###
1087 cat > $tc <<EOT
1088 #include <sys/time.h>
1089 #define __USE_GNU   1
1090 #include <sys/resource.h>
1091 int main() {
1092   struct rusage usage;
1093   getrusage(RUSAGE_THREAD, &usage);
1094   return 0;
1095 }
1096 EOT
1097 test_linkc "whether getrusage accepts RUSAGE_THREAD" "yes" "no" ""
1098 AC_DEFINE_UNQUOTED(CMK_HAS_RUSAGE_THREAD, $pass, [whether getrusage accepts RUSAGE_THREAD])
1099
1100 #### test for asctime ###
1101
1102 cat > $tc <<EOT
1103 #include <time.h>
1104 int main() {
1105   struct tm *local;
1106   time_t t;
1107   t = time(NULL);
1108   local = localtime(&t);
1109   asctime(local);
1110   return 0;
1111 }
1112 EOT
1113 test_linkc "whether has asctime" "yes" "no" ""
1114 AC_DEFINE_UNQUOTED(CMK_HAS_ASCTIME, $pass, [whether has asctime])
1115
1116 #### test for log2 ###
1117 cat > $t <<EOT
1118 #include <math.h>
1119 int main() {
1120   int i = log2(10);
1121   return 0;
1122 }
1123 EOT
1124 test_link "whether has log2" "yes" "no" ""
1125 AC_DEFINE_UNQUOTED(CMK_HAS_LOG2, $pass, [whether has log2])
1126
1127 #### test for sqrtf ###
1128 cat > $t <<EOT
1129 #include <math.h>
1130 int main() {
1131   float i = sqrtf((float)10.0);
1132   return 0;
1133 }
1134 EOT
1135 test_link "whether has sqrtf" "yes" "no" ""
1136 AC_DEFINE_UNQUOTED(CMK_HAS_SQRTF, $pass, [whether has sqrtf])
1137
1138 #### test for fabsf ###
1139 cat > $t <<EOT
1140 #include <math.h>
1141 int main() {
1142   float i = fabsf((float)10.0);
1143   return 0;
1144 }
1145 EOT
1146 test_link "whether has fabsf" "yes" "no" ""
1147 AC_DEFINE_UNQUOTED(CMK_HAS_FABSF, $pass, [whether has fabsf])
1148
1149 #### test for mkstemp ###
1150 cat > $t <<EOT
1151 #include <stdlib.h>
1152 #include <string.h>
1153 int main() {
1154   char fname[[128]];
1155   strcpy(fname, "/tmp/fdXXX.XXX");
1156   mkstemp(fname);
1157   return 0;
1158 }
1159 EOT
1160 test_link "whether has mkstemp" "yes" "no" ""
1161 AC_DEFINE_UNQUOTED(CMK_USE_MKSTEMP, $pass, [whether has mkstemp])
1162
1163 #### test for system ###
1164 cat > $t <<EOT
1165 #include <stdlib.h>
1166 int main() {
1167   system("/bin/ls");
1168   return 0;
1169 }
1170 EOT
1171 test_link "whether has system" "yes" "no" ""
1172 AC_DEFINE_UNQUOTED(CMK_HAS_SYSTEM, $pass, [whether has system])
1173
1174 #### test for sbrk ###
1175 cat > $t <<EOT
1176 #include <unistd.h>
1177 int main() {
1178   void *ptr  = sbrk(0); 
1179 }
1180 EOT
1181 test_link "whether has sbrk" "yes" "no" ""
1182 AC_DEFINE_UNQUOTED(CMK_HAS_SBRK, $pass, [whether has sbrk])
1183
1184 #### test for _setjmp/_longjmp ###
1185 cat > $t <<EOT
1186 #include <setjmp.h>
1187 int main() {
1188   jmp_buf buf;
1189   _setjmp(buf);
1190   _longjmp(buf, 0);
1191 }
1192 EOT
1193 test_link "whether has _setjmp/_longjmp" "yes" "no" ""
1194 AC_DEFINE_UNQUOTED(CMK_HAS_UNDERSCORE_SETJMP, $pass, [whether has _setjmp/_longjmp])
1195
1196 #### test for mstats ###
1197 cat > $t <<EOT
1198 #include <malloc.h>
1199 int main() {
1200   struct mstats ms = mstats();
1201 }
1202 EOT
1203 test_link "whether has mstats" "yes" "no" ""
1204 AC_DEFINE_UNQUOTED(CMK_HAS_MSTATS, $pass, [whether has mstats])
1205
1206 #### test for mallinfo ###
1207 cat > $t <<EOT
1208 #include <malloc.h>
1209 int main() {
1210   struct mallinfo mi = mallinfo();
1211 }
1212 EOT
1213 test_link "whether has mallinfo" "yes" "no" ""
1214 AC_DEFINE_UNQUOTED(CMK_HAS_MALLINFO, $pass, [whether has mallinfo])
1215
1216 #### test for popen ###
1217 cat > $t <<EOT
1218 #include <stdio.h>
1219 int main() {
1220   FILE *p = popen("/bin/ps", "r");
1221   pclose(p);
1222 }
1223 EOT
1224 test_link "whether has popen" "yes" "no" ""
1225 AC_DEFINE_UNQUOTED(CMK_HAS_POPEN, $pass, [whether has popen])
1226
1227 #### test for poll ###
1228 cat > $t <<EOT
1229 #include <poll.h>
1230 void foo(void) { 
1231   struct pollfd pos[[3]];
1232   poll(pos, 1, 1);
1233 }
1234 EOT
1235 test_cxx "whether has poll" "yes" "no" ""
1236 AC_DEFINE_UNQUOTED(CMK_USE_POLL, $pass, [whether the poll syscall exists])
1237
1238 #### check if getpagesize exists ####
1239 cat > $tc <<EOT
1240 #include <unistd.h>
1241
1242 int main(int argc, char **argv) {
1243     int s = getpagesize();
1244 }
1245 EOT
1246 test_linkc "whether has getpagesize" "yes" "no" ""
1247 AC_DEFINE_UNQUOTED(CMK_HAS_GETPAGESIZE, $pass, [whether getpagesize exists])
1248
1249 #### check if getpid exists ####
1250 cat > $tc <<EOT
1251 #include <sys/types.h>
1252 #include <unistd.h>
1253
1254 int main(int argc, char **argv) {
1255     pid_t pid = getpid();
1256 }
1257 EOT
1258 test_linkc "whether has getpid" "yes" "no" ""
1259 AC_DEFINE_UNQUOTED(CMK_HAS_GETPID, $pass, [whether getpid exists])
1260
1261 #### check if kill exists ####
1262 cat > $tc <<EOT
1263 #include <sys/types.h>
1264 #include <unistd.h>
1265 #include <signal.h>
1266
1267 int main(int argc, char**argv) 
1268 {
1269     pid_t pid = getpid();
1270     kill(pid, 9);
1271 }
1272 EOT
1273 test_linkc "whether has kill" "yes" "no" ""
1274 AC_DEFINE_UNQUOTED(CMK_HAS_KILL, $pass, [whether kill exists])
1275
1276 #### test for setpriority ###
1277 cat > $t <<EOT
1278 #include <sys/time.h>
1279 #include <sys/resource.h>
1280 void foo(void) { 
1281   setpriority(PRIO_PROCESS, 0, 0);
1282 }
1283 EOT
1284 test_cxx "whether has setpriority" "yes" "no" ""
1285 AC_DEFINE_UNQUOTED(CMK_HAS_SETPRIORITY, $pass, [whether the setpriority exists])
1286
1287 #### test for system ###
1288 cat > $t <<EOT
1289 #include "ckdll_system.C"
1290 EOT
1291 test_cxx "whether to use signal-safe system() " "yes" "no" ""
1292 AC_DEFINE_UNQUOTED(CMK_SIGSAFE_SYSTEM, $pass, [whether to use signal-safe system()])
1293
1294 ### test sched_setaffinity ####
1295 cat > $tc <<EOT
1296 #define _GNU_SOURCE
1297 #include <sched.h>
1298
1299 int main()
1300 {
1301   cpu_set_t cpuset;
1302   CPU_ZERO(&cpuset);
1303   CPU_SET(0, &cpuset);
1304   if (sched_setaffinity(0, sizeof(cpuset), &cpuset) < 0) {
1305     return -1;
1306   }
1307   return 0;
1308 }
1309 EOT
1310 test_linkc "whether sched_setaffinity call exists" "yes" "no" ""
1311 AC_DEFINE_UNQUOTED(CMK_HAS_SETAFFINITY, $pass, [whether the sched_setaffinity() exists])
1312
1313 ### test pthread_setaffinity_np ####
1314 cat > $tc <<EOT
1315 #include <stdlib.h>
1316 #include <stdio.h>
1317 #include <unistd.h>
1318 #include <pthread.h>
1319
1320 int main()
1321 {
1322   unsigned long mask = 0xffffffff;
1323   unsigned int len = sizeof(mask);
1324
1325   if (pthread_setaffinity_np(pthread_self(), len, &mask) < 0) {
1326     return -1;
1327   }
1328   return 0;
1329 }
1330 EOT
1331 test_linkc "whether pthread_setaffinity_np call exists" "yes" "no" "-lpthread"
1332 AC_DEFINE_UNQUOTED(CMK_HAS_PTHREAD_SETAFFINITY, $pass, [whether the pthread_setaffinity_np() exists])
1333
1334 ### test pthread_spin_lock ####
1335 cat > $tc <<EOT
1336 #include <stdlib.h>
1337 #include <stdio.h>
1338 #include <unistd.h>
1339 #include <pthread.h>
1340
1341 int main()
1342 {
1343   pthread_spinlock_t  lock;
1344
1345   pthread_spin_init(&lock, 0);
1346
1347   pthread_spin_lock(&lock);
1348
1349   return 0;
1350 }
1351 EOT
1352 test_linkc "whether pthread_spin_lock exists" "yes" "no" "-lpthread"
1353 AC_DEFINE_UNQUOTED(CMK_HAS_SPINLOCK, $pass, [whether the pthread_spin_lock exists])
1354
1355 ### check libnuma on Linux ####
1356 if test "$WITH_NUMA" = "yes"
1357 then
1358 cat > $tc <<EOT
1359 #include <stdlib.h>
1360 #include <stdio.h>
1361 #include <linux/mempolicy.h>
1362 #include <numaif.h>
1363 #include <numa.h>
1364
1365 int main()
1366 {
1367   if (get_mempolicy(NULL, NULL, 0, 0, 0) == 0) return 0;
1368   return -1;
1369 }
1370 EOT
1371 test_linkc "whether libnuma exists" "yes" "no" "-lnuma"
1372 AC_DEFINE_UNQUOTED(CMK_HAS_NUMACTRL, $pass, [whether NUMA control related functions exist])
1373 if test $pass -eq 1
1374 then
1375         add_flag 'CMK_SYSLIBS="$CMK_SYSLIBS -lnuma"' "libnuma"
1376 fi
1377 fi
1378
1379 #### check bindprocessors on AIX ####
1380 cat > $tc <<EOT
1381 #include <stdlib.h>
1382 #include <stdio.h>
1383 #include <unistd.h>
1384
1385 #include <sys/processor.h>
1386
1387 int main()
1388 {
1389   int retValue = 0;
1390   int pid;
1391   pid = getpid();
1392   if (bindprocessor(BINDPROCESS, pid, 0) == -1) return -1;
1393   return 0;
1394 }
1395 EOT
1396 test_linkc "whether bindprocessor call exists" "yes" "no" ""
1397 AC_DEFINE_UNQUOTED(CMK_HAS_BINDPROCESSOR, $pass, [whether the bindprocessor()
1398 exists])
1399
1400
1401 #### check if dlopen works ####
1402 skip_dl=0
1403 # for bproc, ignore -ldl
1404 test -n "$CMK_BPROC" && skip_dl=1
1405 test -n "$CMK_NO_DL" && skip_dl=1
1406 dl_opt='-ldl'
1407 #workaround for pgcc 4.0, -ldl crash linking, so use -Wl,-ldl to skip the prelinker.
1408 case "$CMK_CXX" in
1409 pgCC*) dl_opt='-Wl,-ldl' ;;
1410 esac
1411
1412 if test $skip_dl -eq 0 
1413 then
1414
1415 cat > $t <<EOT
1416 #include "ckdll_dlopen.C"
1417 int main() {
1418         CkDll dll("foo.so");
1419         return 0;
1420 }
1421 EOT
1422 test_link "whether dlopen links without $dl_opt" "yes" "no" ""
1423 noldl=$pass
1424 test_link "whether dlopen links with $dl_opt" "yes" "no" "$dl_opt"
1425 if test $pass -eq 1
1426 then 
1427 #dlopen requires -ldl: add it to our link line
1428         add_flag CMK_LIBS='"$CMK_LIBS '$dl_opt'"' "dlopen"
1429 fi
1430
1431 if test $pass -eq 1 -o $noldl -eq 1
1432 then
1433 # One version or another of dlopen worked: compile it in
1434         AC_DEFINE_UNQUOTED(CMK_DLL_USE_DLOPEN, 1, [dlopen])
1435 fi
1436
1437 ### test gethostname ####
1438 cat > $tc <<EOT
1439 #ifdef WIN32
1440 #include <Winsock2.h>
1441 #else
1442 #include <stdlib.h>
1443 #include <stdio.h>
1444 #include <unistd.h>
1445 #endif
1446
1447 int main()
1448 {
1449   char hostname[[1000]];
1450   gethostname(hostname, 999);
1451   return 0;
1452 }
1453 EOT
1454 test_linkc "whether gethostname call exists" "yes" "no" ""
1455 AC_DEFINE_UNQUOTED(CMK_HAS_GETHOSTNAME, $pass, [whether gethostname() exists])
1456
1457 #### check if getProcAddress works ####
1458 cat > $t <<EOT
1459 #include "ckdll_win32.C"
1460 EOT
1461 test_cxx "whether getProcAddress works" "yes" "no" ""
1462 AC_DEFINE_UNQUOTED(CMK_DLL_USE_WIN32, $pass, [whether getProcAddress works])
1463
1464 fi    # end of skip_dl
1465
1466 #### check if socklen_t exists ####
1467 cat > $t <<EOT
1468 #include <sys/types.h>
1469 #include <sys/socket.h>
1470
1471 void foo(void) {
1472         int i;
1473         socklen_t s=sizeof(i);
1474 }
1475 EOT
1476 test_cxx "whether has socklen_t" "yes" "no" ""
1477 AC_DEFINE_UNQUOTED(CMK_HAS_SOCKLEN, $pass, [whether has socklen_t])
1478
1479 ### test getifaddrs ####
1480 cat > $tc <<EOT
1481 #include <netinet/in.h> /* for sockaddr_in */
1482 #include <ifaddrs.h> /* for getifaddrs */
1483 #include <net/if.h> /* for IFF_RUNNING */
1484
1485 int main()
1486 {
1487   struct ifaddrs *interfaces=0;
1488   if( getifaddrs(&interfaces) == 0 ) {
1489         struct ifaddrs *interface;
1490         for( interface=interfaces; interface; interface=interface->ifa_next ) {
1491             if( (interface->ifa_flags & IFF_UP) && ! (interface->ifa_flags & IFF_LOOPBACK) ) {
1492                 const struct sockaddr_in *addr = (const struct sockaddr_in*)interface->ifa_addr;
1493                 if( addr && addr->sin_family==AF_INET ) {
1494                     break;
1495                 }
1496             }
1497         }
1498         freeifaddrs(interfaces);
1499   }
1500 }
1501 EOT
1502 test_linkc "whether getifaddrs call exists" "yes" "no" ""
1503 AC_DEFINE_UNQUOTED(CMK_HAS_GETIFADDRS, $pass, [whether getifaddrs() exists])
1504
1505 #### check if mmap exists ####
1506 cat > $t <<EOT
1507 #include <sys/types.h>
1508 #include <sys/mman.h>
1509
1510 void *foo(void *a,int l,int fd) {
1511         return mmap((caddr_t)a,l,PROT_READ+PROT_WRITE,
1512                  MAP_FIXED+MAP_PRIVATE,fd,0);
1513 }
1514 EOT
1515 test_cxx "whether the mmap() syscall exists" "yes" "no" ""
1516 AC_DEFINE_UNQUOTED(CMK_HAS_MMAP, $pass, [whether the mmap() syscall exists])
1517
1518 #### check if mmap accepts MAP_ANON ####
1519 cat > $t <<EOT
1520 #include <sys/types.h>
1521 #include <sys/mman.h>
1522
1523 void *foo(void *a,int l) {
1524         return mmap((caddr_t)a,l,PROT_READ+PROT_WRITE,
1525                 MAP_FIXED+MAP_PRIVATE+MAP_ANON,-1,0);
1526 }
1527 EOT
1528 test_cxx "whether mmap() accepts MAP_ANON" "yes" "no" ""
1529 AC_DEFINE_UNQUOTED(CMK_HAS_MMAP_ANON, $pass, [whether mmap() accepts MAP_ANON])
1530
1531 #### check if mmap accepts MAP_NORESERVE ####
1532 cat > $t <<EOT
1533 #include <sys/types.h>
1534 #include <sys/mman.h>
1535
1536 void *foo(void *a,int l) {
1537         return mmap((caddr_t)a,l,PROT_READ+PROT_WRITE,
1538                 MAP_FIXED+MAP_PRIVATE+MAP_NORESERVE,-1,0);
1539 }
1540 EOT
1541 test_cxx "whether mmap() accepts MAP_NORESERVE" "yes" "no" ""
1542 AC_DEFINE_UNQUOTED(CMK_HAS_MMAP_NORESERVE, $pass, [whether mmap() accepts MAP_NORESERVE])
1543
1544 #### check if get_myaddress exists ####
1545 cat > $t <<EOT
1546 #include <rpc/rpc.h>
1547
1548 void foo(void *a) {
1549     get_myaddress((struct sockaddr_in*)a);
1550 }
1551 EOT
1552 test_cxx "whether has get_myaddress" "yes" "no" ""
1553 AC_DEFINE_UNQUOTED(CMK_HAS_GET_MYADDRESS, $pass, [whether has get_myaddress])
1554
1555 #### check if mprotect exists ####
1556 cat > $t <<EOT
1557 #include <stdio.h>
1558 #include <sys/mman.h>
1559
1560 void foo(void *a,int l,int fd) {
1561      void *pg = NULL;
1562      size_t pagesize = 4096;
1563      mprotect(pg, pagesize, PROT_READ | PROT_WRITE);
1564 }
1565 EOT
1566 test_cxx "whether has mprotect" "yes" "no" ""
1567 AC_DEFINE_UNQUOTED(CMK_HAS_MPROTECT, $pass, [whether has mprotect])
1568
1569 #### check if glibc backtrace exists ####
1570 cat > $t <<EOT
1571 #include "cmibacktrace.c"
1572
1573 int main() {
1574         int nLevels=1;
1575         void *stack;
1576         CmiBacktraceRecord(&stack,0,&nLevels);
1577         return 0;
1578 }
1579 EOT
1580 TRACE_LINK_FLAG="-rdynamic"
1581 test_link "whether glibc backtrace works" "yes" "no" "-DCMK_USE_BACKTRACE=1 $TRACE_LINK_FLAG"
1582 AC_DEFINE_UNQUOTED(CMK_USE_BACKTRACE, $pass, [whether glibc backtrace works])
1583
1584 if test $strictpass -eq 1
1585 then 
1586         add_flag 'CMK_LD="$CMK_LD '$TRACE_LINK_FLAG'"' "backtrace"
1587         add_flag 'CMK_LDXX="$CMK_LDXX '$TRACE_LINK_FLAG'"' "backtrace"
1588 fi
1589
1590 #### test sleep ####
1591 cat > $t <<EOT
1592 #include <unistd.h>
1593 int main() {
1594   sleep(1);
1595   return 0;
1596 }
1597 EOT
1598 test_cxx "whether has sleep " "yes" "no" ""
1599 AC_DEFINE_UNQUOTED(CMK_HAS_SLEEP, $pass, [whether has sleep])
1600
1601 #### test usleep ####
1602 cat > $t <<EOT
1603 #include <unistd.h>
1604 int main() {
1605   usleep(100);
1606   return 0;
1607 }
1608 EOT
1609 test_cxx "whether has usleep " "yes" "no" ""
1610 AC_DEFINE_UNQUOTED(CMK_HAS_USLEEP, $pass, [whether has usleep])
1611
1612 #### test personality() and ADDR_NO_RANDOMIZE ####
1613 # Only works on modern Linux systems
1614 cat > $t <<EOT
1615 #include <sys/personality.h>
1616 int main() {
1617     int orig_persona = personality(0xffffffff);
1618     personality(orig_persona | ADDR_NO_RANDOMIZE);
1619     return 0;
1620 }
1621 EOT
1622 test_cxx "whether personality() and ADDR_NO_RANDOMIZE exist" "yes" "no" ""
1623 AC_DEFINE_UNQUOTED(CMK_HAS_ADDR_NO_RANDOMIZE, $pass, [whether personality() and ADDR_NO_RANDOMIZE exist])
1624
1625
1626 #### test if has zlib ####
1627 # bproc doesnot like -lz in any case
1628 if test -z "$CMK_BPROC"
1629 then
1630
1631 cat > $t <<EOT
1632 #include <zlib.h>
1633 int main() { 
1634   gzFile f = gzopen("/tmp/x","r");
1635   gzprintf(f, "test...\n");
1636   gzclose(f);
1637   return 0;
1638 }
1639 EOT
1640 test_link "whether has zlib" "yes" "no" "-lz"
1641 AC_DEFINE_UNQUOTED(CMK_PROJECTIONS_USE_ZLIB, $pass, [whether has zlib])
1642 if test $pass -eq 1
1643 then 
1644         add_flag 'CMK_LIBZ="-lz"' "zlib"
1645 fi
1646
1647 fi
1648
1649 #### test if has elf.h ####
1650 cat > $t <<EOT
1651 #include <elf.h>
1652 typedef Elf32_Addr ELF_TYPE_Addr;
1653 int main() { 
1654 }
1655 EOT
1656 test_cxx "whether has elf.h " "yes" "no" ""
1657 AC_DEFINE_UNQUOTED([CMK_HAS_ELF_H], $pass, [whether has elf.h])
1658
1659 #### test if has Multiprocessing.h for apple ####
1660 cat > $t <<EOT
1661 #include <Carbon/Carbon.h>
1662 #include <Multiprocessing.h>
1663 int main() {
1664   int a = MPProcessorsScheduled();
1665 }
1666 EOT
1667 test_cxx "whether has Multiprocessing.h for Apple " "yes" "no" ""
1668 AC_DEFINE_UNQUOTED([CMK_HAS_MULTIPROCESSING_H], $pass, [whether has Multiprocessing.h])
1669
1670 #### test if "ntohl" is available ####
1671 cat > $t <<EOT
1672 #if defined(_WIN32) && ! defined(__CYGWIN__) || defined(__MINGW_H)
1673 #include <winsock.h>
1674 #else
1675 #include <stdint.h>
1676 #include <arpa/inet.h>
1677 #include <netinet/in.h>
1678 #endif
1679
1680 int main() {
1681   int i = 100;
1682   i = ntohl(i);
1683   return 0;
1684 }
1685 EOT
1686 test_link "whether ntohl is available" "yes" "no" ""
1687 AC_DEFINE_UNQUOTED(CMK_HAS_NTOHL, $pass, [whether ntohl is available])
1688
1689 ### test for libjpeg ####
1690 cat > $t <<EOT
1691 #include <stdio.h>
1692 #include <stdlib.h>
1693 #include "jpeglib.h"
1694
1695 int main()
1696 {
1697   struct jpeg_compress_struct cinfo;
1698   jpeg_create_compress(&cinfo);
1699   return 0;
1700 }
1701 EOT
1702 test_link "whether has libjpeg" "yes" "no" "-ljpeg"
1703 AC_DEFINE_UNQUOTED(CMK_USE_LIBJPEG, $pass, [whether has libjpeg])
1704 if test $pass -eq 1
1705 then
1706         add_flag 'CMK_LIBJPEG="-ljpeg"' "libjpeg"
1707 fi
1708
1709 #### check if PAPI exists ####
1710 if test -n "$CMK_USE_PAPI"
1711 then
1712 cat > $t <<EOT
1713 #include <stdio.h>
1714 #include <papi.h>
1715                                                                                 
1716 int main() {
1717     if (PAPI_library_init(PAPI_VER_CURRENT) != PAPI_VER_CURRENT) return 1;
1718     return 0;
1719 }
1720 EOT
1721 test_link "whether PAPI exists" "yes" "no" "-lpapi"
1722 AC_DEFINE_UNQUOTED(CMK_HAS_COUNTER_PAPI, $pass, [whether PAPI exists])
1723 if test $pass -eq 1
1724 then 
1725         add_flag 'CMK_LIBS="$CMK_LIBS -lpapi"' "papi"
1726 fi
1727 fi
1728
1729 #### test if Python headers are installed ####
1730 PYTHON_VERSION=`python -V 2>&1 | awk {'print $2'} | awk -F. {'print $1"."$2'}`
1731 cat > $t <<EOT
1732 #include "python${PYTHON_VERSION}/Python.h"
1733 #include "python${PYTHON_VERSION}/compile.h"
1734 #include "python${PYTHON_VERSION}/eval.h"
1735 #include "python${PYTHON_VERSION}/node.h"
1736
1737 int main() {
1738     Py_Initialize();
1739     PyEval_InitThreads();
1740     struct _node* programNode = PyParser_SimpleParseString("return 1\n",Py_file_input);
1741     PyCodeObject *program = PyNode_Compile(programNode, "");
1742 }
1743 EOT
1744 test_link "whether Python is installed" "yes" "no" "-lpython$PYTHON_VERSION -lpthread -lutil -ldl"
1745 AC_DEFINE_UNQUOTED(CMK_HAS_PYTHON, $pass, [whether Python is installed])
1746 AC_DEFINE_UNQUOTED(CMK_PYTHON_VERSION, ${PYTHON_VERSION}, [Python version])
1747 if test $pass -eq 1
1748 then
1749         add_flag "CMK_BUILD_PYTHON=$PYTHON_VERSION" "python"
1750 fi
1751
1752 #### Pick up METIS if the user asks for it ####
1753
1754 AC_ARG_WITH([metis],
1755             [AS_HELP_STRING([--with-metis],
1756              [support the METIS graph partitioner and associated load balancer])],
1757             [],
1758             [with_metis=no])
1759
1760 WITH_METIS=no
1761 if test "$with_metis" != "no"
1762 then
1763   Echo "Compiling Charm with support for METIS"
1764   WITH_METIS=yes
1765   echo 'charm++: $(L)/libmoduleMetisLB.a $(L)/libmoduleTeamLB.a' >> $MAKEFILE_EXT
1766   add_flag 'CMK_LIBS="$CMK_LIBS -lmetis"' "libmetis"
1767   if test "$with_metis" != "yes"
1768   then
1769     add_flag "CMK_METIS=$with_metis" "Where to find METIS"
1770     add_flag 'CMK_LIBDIR="$CMK_LIBDIR -L$CMK_METIS"' "Library path for METIS"
1771     if test -r $with_metis/Lib/metis.h
1772     then
1773       add_flag 'CMK_INCDIR="$CMK_INCDIR -I$CMK_METIS/Lib"' "Include path for METIS 4"
1774     elif test -r $with_metis/../../include/metis.h
1775     then
1776       add_flag 'CMK_INCDIR="$CMK_INCDIR -I$CMK_METIS/../../include"' "Include path for METIS 5"
1777     else
1778       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."
1779       test_finish 1
1780     fi
1781   fi
1782 fi
1783
1784 ## Cray specific test
1785 if test "$CMK_BUILD_CRAY" = "1"
1786 then
1787
1788 #### test if Cray node topology will work ####
1789 cat > $tc <<EOT
1790 #include <pmi.h>
1791
1792 int main() {
1793     int nid;
1794     PMI_Get_nid(0, &nid);
1795
1796     return 0;
1797 }
1798 EOT
1799 test_linkc "whether PMI_Get_nid exists" "yes" "no" ""
1800 AC_DEFINE_UNQUOTED(CMK_HAS_PMI_GET_NID, $pass, [whether PMI_Get_nid exists])
1801
1802 #### test if Cray mesh topology will work ####
1803 cat > $tc <<EOT
1804 #include <rca_lib.h>
1805
1806 int main() {
1807     rca_mesh_coord_t xyz;
1808     rca_get_meshcoord(0, &xyz);
1809
1810     return 0;
1811 }
1812 EOT
1813 test_linkc "whether Cray rca library is available" "yes" "no" "-lrca"
1814 AC_DEFINE_UNQUOTED(CMK_HAS_RCALIB, $pass, [whether Cray rca library is available])
1815
1816 fi
1817
1818 #### test if it can build shared library ####
1819 cat > $t <<EOT
1820 #include "stdlib.h"
1821 extern int foo();
1822 int foo1() { 
1823   void * t= malloc(2);
1824   foo();
1825   return 0;
1826 }
1827 EOT
1828 test_linkso "whether can build shared library" "yes" "no" ""
1829 if test $pass -eq 0
1830 then 
1831         add_flag 'CMK_NO_BUILD_SHARED="true"' "build-shared"
1832 else
1833         BUILD_SHARED=1
1834         if test "$BUILD_MPI" = "1"
1835         then
1836 cat > $t <<EOT
1837 #include "stdlib.h"
1838 #include "mpi.h"
1839 extern int foo();
1840 int foo(int argc, char ** argv) {
1841   void * t= malloc(2);
1842   foo();
1843   MPI_Init(&argc, &argv);
1844   return 0;
1845 }
1846 EOT
1847                 test_linkso "whether can build shared library with MPI" "yes" "no" ""
1848                 BUILD_SHARED=$pass
1849         fi
1850         if test $BUILD_SHARED -eq 0
1851         then
1852                 add_flag 'CMK_NO_BUILD_SHARED="true"' "build-shared"
1853         fi
1854 fi
1855
1856 #### test the version number of bproc ####
1857 if test -n "$CMK_BPROC"
1858 then
1859 cat > $t <<EOT
1860 #include <stdio.h>
1861 #include <sys/bproc.h>
1862 int main()
1863 {
1864   struct bproc_version_t vers;
1865   bproc_version(&vers);
1866   printf("%s\n", vers.version_string);
1867 }
1868 EOT
1869 test_link "whether bproc compiles" "yes" "no" "-lbproc"
1870 if test $pass -eq 1
1871 then 
1872 AC_MSG_CHECKING("bproc version")
1873 bproc_ver=`./testlink`
1874 if test x$bproc_ver = x
1875 then
1876 test_result 0 "bproc version" "ERROR" ""
1877 test_finish 1
1878 else
1879 test_result 0 "bproc version" "$bproc_ver" ""
1880 fi
1881 bproc_ver=`echo $bproc_ver | cut -d'.' -f1`
1882 AC_DEFINE_UNQUOTED(CMK_BPROC_VERSION, $bproc_ver, [bproc version])
1883 fi
1884 fi
1885
1886 #### test the if command sync exists ####
1887 AC_CHECK_PROG(SYNC, sync, sync )
1888 if test -n "$SYNC"
1889 then
1890 AC_DEFINE_UNQUOTED(CMK_HAS_SYNC, 1, [sync program])
1891 fi
1892
1893 ################## Fortran #########################
1894
1895 #echo "set F77 compiler as: $CMK_CF77"
1896 AC_MSG_CHECKING("F77 compiler as")
1897 AC_MSG_RESULT("$CMK_CF77")
1898
1899 AC_MSG_CHECKING("whether Fortran 77 compiler works")
1900 ### test fortran 77 compiler ###
1901 cat > conftest.f <<EOF
1902       SUBROUTINE FOO_foo
1903       END
1904 EOF
1905 $CMK_CF77 -c conftest.f > /dev/null 2> /dev/null
1906 if test ! -r conftest.o
1907 then
1908   AC_MSG_RESULT("no")
1909 else
1910   AC_MSG_RESULT("yes")
1911 fi
1912
1913 ### test fortran 90 compiler ###
1914 #echo "set F90 compiler as: $CMK_CF90"
1915 AC_MSG_CHECKING("F90 compiler as")
1916 AC_MSG_RESULT("$CMK_CF90")
1917
1918 AC_MSG_CHECKING("whether Fortran 90 compiler works")
1919 cat > conftest2.f90 <<EOF
1920       SUBROUTINE FOO_foo
1921       END
1922 EOF
1923 $CMK_CF90 -c conftest2.f90 > /dev/null 2> /dev/null
1924 if test ! -r conftest2.o
1925 then
1926   AC_MSG_RESULT("no")
1927 else
1928   AC_MSG_RESULT("yes")
1929   mv -f conftest2.o conftest.o
1930   USE_FORTRAN90=1
1931 fi
1932
1933 ### check fortran name mangling
1934 AC_MSG_CHECKING(subroutine name used by Fortran 90 compiler)
1935
1936 if test -r conftest.o
1937 then
1938   AC_CACHE_VAL(_cv_fortran_postfix,
1939
1940   NAME=`$CMK_NM conftest.o | grep "foo_foo__"`
1941   if test "$NAME" != ""
1942   then
1943     _cv_fortran_postfix=TWOSCORE
1944     AC_DEFINE_UNQUOTED(CMK_FORTRAN_USES_TWOSCORE, 1, [TWOSCORE])
1945   else
1946     NAME=`$CMK_NM conftest.o | grep "foo_foo_"`
1947     if test "$NAME" != ""
1948     then
1949       _cv_fortran_postfix=ONESCORE
1950       AC_DEFINE_UNQUOTED(CMK_FORTRAN_USES_ONESCORE, 1, [ONESCORE])
1951     else
1952       NAME=`$CMK_NM conftest.o | grep "foo_foo"`
1953       if test "$NAME" != ""
1954       then
1955         _cv_fortran_postfix=NOSCORE
1956         AC_DEFINE_UNQUOTED(CMK_FORTRAN_USES_NOSCORE, 1, [NOSCORE])
1957       else
1958         NAME=`$CMK_NM conftest.o | grep "FOO_FOO"`
1959         if test "$NAME" != ""
1960         then
1961           _cv_fortran_postfix=ALLCAPS
1962           AC_DEFINE_UNQUOTED(CMK_FORTRAN_USES_ALLCAPS, 1, [ALLCAPS])
1963         else
1964           echo "#################################################"
1965           echo "FORTRAN compiler generated name not supported yet"
1966           echo "#################################################"
1967         fi
1968       fi
1969     fi
1970   fi
1971   rm -f conftest.f conftest.o
1972   )
1973   AC_MSG_RESULT($_cv_fortran_postfix)
1974 else
1975   AC_MSG_RESULT("Fortran compiler not working")
1976 fi
1977
1978 ### check module name ###
1979
1980 if test "$USE_FORTRAN90" = 1
1981 then
1982   cat > conftest.f90 <<EOF
1983       MODULE testmod
1984         interface 
1985           function fpup_issizing(p)
1986           INTEGER :: p
1987           logical fpup_issizing
1988           end function
1989         end interface
1990       END MODULE
1991 EOF
1992   AC_MSG_CHECKING(Fortran 90 mod name is capital)
1993   $CMK_CF90 -c conftest.f90 > /dev/null 2> /dev/null
1994   name=`ls TESTMOD.* 2>/dev/null`
1995   if test -n "$name"
1996   then
1997         AC_MSG_RESULT("yes")
1998         add_flag 'CMK_MOD_NAME_ALLCAPS=1' "mod name capital"
1999   else
2000         AC_MSG_RESULT("no")
2001         name=`ls testmod.* 2>/dev/null`
2002   fi
2003   if test -n "$name"
2004   then
2005         AC_MSG_CHECKING(Fortran 90 mod name extension)
2006         ext=`echo $name | sed -e 's/^[[^.]]*\.//'`
2007         add_flag 'CMK_MOD_EXT="'$ext'"' "mod name extension"
2008         AC_MSG_RESULT("$ext")
2009         /bin/rm -f $name
2010   fi
2011   /bin/rm -f conftest.f90
2012 fi
2013
2014 AC_OUTPUT(
2015 libs/ck-libs/ampi/ampiCC libs/ck-libs/ampi/ampirun,
2016
2017 chmod +x libs/ck-libs/ampi/ampiCC libs/ck-libs/ampi/ampirun
2018 )