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