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