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