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