bba5ef2ae96a0102f1a8cc038a821bbc8f090b06
[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 the stl headers use .h #####
602 cat > $t <<EOT
603 #include <iostream>
604 void foo(void) { std::cout<<"Hello, world"<<std::endl; }
605 EOT
606 test_cxx "whether including STL <foo> works" "ok" "no" ""
607 AC_DEFINE_UNQUOTED(CMK_STL_USE_DOT_H, $fail, [including STL <foo> does not works])
608 AC_DEFINE_UNQUOTED(CMK_STL_DONT_USE_DOT_H, $pass, [including STL <foo> works])
609
610 #### check if std::vector works ######
611 cat > $t <<EOT
612 #include <vector>
613
614 int foo(void) {
615   std::vector<int> v;      
616   v.push_back(2); v.push_back(3);
617   std::vector<int>::iterator it=v.begin();
618   it++;
619   return *it;
620 }
621 EOT
622 test_cxx "whether the std:: names for STL work" "ok" "no" ""
623 AC_DEFINE_UNQUOTED(CMK_USE_STL, $pass, [whether the std:: names for STL work])
624
625 #### check if namespaces can be defined #####
626 cat > $t <<EOT
627 namespace foo {
628         int x;
629 }
630 EOT
631 test_cxx "whether namespaces work" "ok" "no" ""
632 AC_DEFINE_UNQUOTED(CMK_NAMESPACES_BROKEN, $fail, [whether namespaces work])
633
634
635 #### check if typeinfo exists and works #####
636 cat > $t <<EOT
637 #include <typeinfo>
638 const char *foo(void) {
639         int x;
640         return typeid(x).name();
641 }
642 EOT
643 test_cxx "whether typeinfo/typeid works" "ok" "no" ""
644 AC_DEFINE_UNQUOTED(CMK_HAS_TYPEINFO, $pass, [whether typeinfo/typeid works])
645
646 #### check if iterator_traits is defined #####
647 cat > $t <<EOT
648 #include <iterator>
649
650 template <typename T> // T models Input Iterator
651 typename std::iterator_traits<T>::value_type accumulate(T first, T last)
652 {
653       typename std::iterator_traits<T>::value_type result = 0;
654       while(first != last)
655             result += *first++;
656       return result;
657 }
658 EOT
659 test_cxx "whether std::iterator_traits is defined" "ok" "no" ""
660 AC_DEFINE_UNQUOTED(CMK_HAS_ITERATOR_TRAITS, $pass, [whether iterator_traits works])
661
662 #### check if std::distance is defined #####
663 cat > $t <<EOT
664 #include <vector>
665 #include <iterator>
666
667 int foo()
668 {
669   std::vector<int> tree;
670   return std::distance(tree.begin(), tree.end());
671 }
672 EOT
673 test_cxx "whether std::distance is defined" "ok" "no" ""
674 AC_DEFINE_UNQUOTED(CMK_HAS_STD_DISTANCE, $pass, [whether std::distance works])
675
676 #### check if std::inserter is defined #####
677 cat > $t <<EOT
678 #include <list>
679 #include <iterator>
680
681 void foo()
682 {
683   using namespace std;
684   list<int> L;
685   inserter ( L, L.end ( ) ) = 500;
686 }
687 EOT
688 test_cxx "whether std::inserter is defined" "ok" "no" ""
689 AC_DEFINE_UNQUOTED(CMK_HAS_STD_INSERTER, $pass, [whether std::inserter works])
690
691
692 #### test if we can have multiple delete like this ####
693 cat > $t <<EOT
694 class foo {
695 public:
696   void operator delete(void*p){};
697   void operator delete(void*p,int*){};
698 };
699 EOT
700 test_cxx "whether operator delete can be overloaded in same class" "ok" "no" ""
701 AC_DEFINE_UNQUOTED(CMK_MULTIPLE_DELETE, $strictpass, [whether operator delete can be overloaded in same class])
702
703
704 #### test if we can use gcc x86 assembly like this ####
705 cat > $t <<EOT
706 double foo(void)
707 {
708   unsigned long long int v;
709   int *lo=0+(int *)&v;
710   int *hi=1+(int *)&v;
711   __asm__ __volatile__(
712       "rdtsc; movl %%edx,%0; movl %%eax,%1"
713       : /* output  */ "=m" (*hi), "=m" (*lo)
714       : /* input */
715       : /* trashes */ "%edx", "%eax"
716   );
717   return v;
718 }
719 EOT
720 test_cxx "whether GCC x86 assembly works" "yes" "no" ""
721 AC_DEFINE_UNQUOTED(CMK_GCC_X86_ASM, $strictpass, [Allows gcc x86 assembly.])
722
723 #### test if we can use gcc x86 assembly like this ####
724 if test $strictpass = 1
725 then
726 cat > $t <<EOT
727 int foo(void)
728 {
729   int x;
730   asm("lock incl %0" :: "m" (x));
731   asm("lock decl %0" :: "m" (x));
732   return x;
733 }
734 EOT
735 test_cxx "whether GCC x86 assembly for atomic increment works" "yes" "no" ""
736 AC_DEFINE_UNQUOTED(CMK_GCC_X86_ASM_ATOMICINCREMENT, $strictpass, [Allows gcc x86 assembly for atomic increment.])
737 fi
738
739 #### test if we can use gcc IA64 assembly like this ####
740 cat > $t <<EOT
741 double foo(void)
742 {
743         unsigned long long int x;
744         __asm__ __volatile__("mov %0=ar.itc" : "=r"(x) :: "memory");
745         return x;
746 }
747 EOT
748 test_cxx "whether GCC IA64 assembly works" "yes" "no" ""
749 AC_DEFINE_UNQUOTED(CMK_GCC_IA64_ASM, $strictpass, [Allows gcc IA64 assembly.])
750
751
752 #### test if we can use PPC assembly like this ####
753 cat > $t <<EOT
754 double foo(void)
755 {
756         unsigned long long int x;
757         asm volatile("eieio" ::: "memory");
758         return x;
759 }
760 EOT
761 test_cxx "whether PPC assembly works" "yes" "no" ""
762 AC_DEFINE_UNQUOTED(CMK_PPC_ASM, $strictpass, [Allows PPC assembly.])
763
764
765
766 #### test if we can use __thread ####
767 cat > $t <<EOT
768 __thread unsigned long long int x;
769 static __thread  int y;
770 void foo(void)
771 {
772         x = 1;
773         y = 1;
774 }
775 EOT
776 test_cxx "whether __thread (Thread Local Storage) is supported" "yes" "no" ""
777 AC_DEFINE_UNQUOTED(CMK_TLS_THREAD, $strictpass, [Allows __thread.])
778
779 ### test if switching TLS register ###
780 if test $in64bit = 1
781 then
782 cat > $t <<EOT
783 #include <elf.h>
784 #include <stdlib.h>
785 #include <malloc.h>
786
787 void switchTLS() {
788   Elf64_Addr m1, m2;
789   asm volatile ("movq %%fs:0x0, %0\n\t"
790                 "movq %1, %%fs:0x0\n\t"
791                 : "=r"(m1)
792                 : "r"(m2));
793 }
794 EOT
795 test_cxx "whether switching TLS register (64-bit) is supported" "yes" "no" ""
796 AC_DEFINE_UNQUOTED(CMK_TLS_SWITCHING64, $strictpass, [Allows switching TLS 64-bit.])
797 else
798 cat > $t <<EOT
799 #include <elf.h>
800 #include <stdlib.h>
801 #include <malloc.h>
802
803 void switchTLS() {
804   Elf32_Addr m1, m2;
805   asm volatile ("movl %%gs:0x0, %0\n\t"
806                 "movl %1, %%gs:0x0\n\t"
807                 : "=r"(m1)
808                 : "r"(m2));
809 }
810 EOT
811 test_cxx "whether switching TLS register (32-bit) is supported" "yes" "no" ""
812 AC_DEFINE_UNQUOTED(CMK_TLS_SWITCHING32, $strictpass, [Allows switching TLS in 32-bit.])
813 fi
814
815 #### test if we can build MPI ####
816 if test "$CMK_BUILD_MPI" = 1
817 then
818
819 cat > $t <<EOT
820 #include "mpi.h"
821 int main(int argc, char **argv)
822 {
823   MPI_Init(&argc, &argv);
824 }
825 EOT
826 mv -f ../include/mpi.h ../include/mpi.h.bak 2>/dev/null
827 test_cxx "whether build on MPI" "yes" "no" ""
828 AC_DEFINE_UNQUOTED(CMK_BUILD_ON_MPI, $strictpass, [build MPI.])
829 BUILD_MPI=$strictpass
830
831 if test $BUILD_MPI -eq 0
832 then
833   echo "Error: Can not compile a MPI program"
834   test_finish 1
835 fi
836
837 if test $BUILD_MPI -eq 1
838 then
839   test_link "whether need to specify MPI library" "no" "yes" ""
840   if test $pass -ne 1
841   then
842     if test -z "$CMK_MPI_LIB"
843     then
844       test_link "whether -lmpich" "ok" "no" "-lmpich"
845       if test $pass -eq 1
846       then
847         add_flag CMK_SYSLIBS='"$CMK_SYSLIBS -lmpich"' "mpi lib"
848       else
849         test_link "whether -lmpi" "ok" "no" "-lmpi"
850         if test $pass -eq 1
851         then
852                 add_flag CMK_SYSLIBS='"$CMK_SYSLIBS -lmpi"' "mpi lib"
853         else
854                 echo "Error: can not find mpi library"
855                 test_finish 1
856         fi
857       fi
858     else
859       add_flag CMK_SYSLIBS='"$CMK_SYSLIBS $CMK_MPI_LIB"' "mpi lib"
860     fi
861   fi
862 fi
863
864 if test "$BUILD_MPI" = "1"
865 then
866 cat > $t <<EOT
867 #include "mpi.h"
868 int main(int argc, char **argv)
869 {
870   int thread_level, provided;
871   thread_level = MPI_THREAD_FUNNELED;
872   MPI_Init_thread(&argc, &argv, thread_level, &provided);
873 }
874 EOT
875 test_cxx "whether MPI_Init_thread is supported" "yes" "no" ""
876 AC_DEFINE_UNQUOTED(CMK_MPI_INIT_THREAD, $strictpass, [Allows MPI_Init_thread.])
877 fi
878 mv -f ../include/mpi.h.bak ../include/mpi.h 2>/dev/null
879
880 fi
881
882 ################### Syscalls and Libraries ###################
883
884 #### test for getrusage with RUSAGE_THREAD ###
885 cat > $tc <<EOT
886 #include <sys/time.h>
887 #define __USE_GNU   1
888 #include <sys/resource.h>
889 int main() {
890   struct rusage usage;
891   getrusage(RUSAGE_THREAD, &usage);
892   return 0;
893 }
894 EOT
895 test_linkc "whether getrusage accepts RUSAGE_THREAD" "yes" "no" ""
896 AC_DEFINE_UNQUOTED(CMK_HAS_RUSAGE_THREAD, $pass, [whether getrusage accepts RUSAGE_THREAD])
897
898 #### test for log2 ###
899 cat > $t <<EOT
900 #include <math.h>
901 int main() {
902   int i = log2(10);
903   return 0;
904 }
905 EOT
906 test_link "whether has log2" "yes" "no" ""
907 AC_DEFINE_UNQUOTED(CMK_HAS_LOG2, $pass, [whether has log2])
908
909 #### test for sqrtf ###
910 cat > $t <<EOT
911 #include <math.h>
912 int main() {
913   float i = sqrtf((float)10.0);
914   return 0;
915 }
916 EOT
917 test_link "whether has sqrtf" "yes" "no" ""
918 AC_DEFINE_UNQUOTED(CMK_HAS_SQRTF, $pass, [whether has sqrtf])
919
920 #### test for fabsf ###
921 cat > $t <<EOT
922 #include <math.h>
923 int main() {
924   float i = fabsf((float)10.0);
925   return 0;
926 }
927 EOT
928 test_link "whether has fabsf" "yes" "no" ""
929 AC_DEFINE_UNQUOTED(CMK_HAS_FABSF, $pass, [whether has fabsf])
930
931 #### test for mkstemp ###
932 cat > $t <<EOT
933 #include <stdlib.h>
934 #include <string.h>
935 int main() {
936   char fname[[128]];
937   strcpy(fname, "/tmp/fdXXX.XXX");
938   mkstemp(fname);
939   return 0;
940 }
941 EOT
942 test_link "whether has mkstemp" "yes" "no" ""
943 AC_DEFINE_UNQUOTED(CMK_USE_MKSTEMP, $pass, [whether has mkstemp])
944
945 #### test for system ###
946 cat > $t <<EOT
947 #include <stdlib.h>
948 int main() {
949   system("/bin/ls");
950   return 0;
951 }
952 EOT
953 test_link "whether has system" "yes" "no" ""
954 AC_DEFINE_UNQUOTED(CMK_HAS_SYSTEM, $pass, [whether has system])
955
956 #### test for sbrk ###
957 cat > $t <<EOT
958 #include <unistd.h>
959 int main() {
960   void *ptr  = sbrk(0); 
961 }
962 EOT
963 test_link "whether has sbrk" "yes" "no" ""
964 AC_DEFINE_UNQUOTED(CMK_HAS_SBRK, $pass, [whether has sbrk])
965
966 #### test for mstats ###
967 cat > $t <<EOT
968 #include <malloc.h>
969 int main() {
970   struct mstats ms = mstats();
971 }
972 EOT
973 test_link "whether has mstats" "yes" "no" ""
974 AC_DEFINE_UNQUOTED(CMK_HAS_MSTATS, $pass, [whether has mstats])
975
976 #### test for mallinfo ###
977 cat > $t <<EOT
978 #include <malloc.h>
979 int main() {
980   struct mallinfo mi = mallinfo();
981 }
982 EOT
983 test_link "whether has mallinfo" "yes" "no" ""
984 AC_DEFINE_UNQUOTED(CMK_HAS_MALLINFO, $pass, [whether has mallinfo])
985
986 #### test for popen ###
987 cat > $t <<EOT
988 #include <stdio.h>
989 int main() {
990   FILE *p = popen("/bin/ps", "r");
991   pclose(p);
992 }
993 EOT
994 test_link "whether has popen" "yes" "no" ""
995 AC_DEFINE_UNQUOTED(CMK_HAS_POPEN, $pass, [whether has popen])
996
997 #### test for poll ###
998 cat > $t <<EOT
999 #include <poll.h>
1000 void foo(void) { 
1001   struct pollfd pos[[3]];
1002   poll(pos, 1, 1);
1003 }
1004 EOT
1005 test_cxx "whether has poll" "yes" "no" ""
1006 AC_DEFINE_UNQUOTED(CMK_USE_POLL, $pass, [whether the poll syscall exists])
1007
1008 #### check if getpagesize exists ####
1009 cat > $tc <<EOT
1010 #include <unistd.h>
1011
1012 int main(int argc, char **argv) {
1013     int s = getpagesize();
1014 }
1015 EOT
1016 test_linkc "whether has getpagesize" "yes" "no" ""
1017 AC_DEFINE_UNQUOTED(CMK_HAS_GETPAGESIZE, $pass, [whether getpagesize exists])
1018
1019 #### check if getpid exists ####
1020 cat > $tc <<EOT
1021 #include <sys/types.h>
1022 #include <unistd.h>
1023
1024 int main(int argc, char **argv) {
1025     pid_t pid = getpid();
1026 }
1027 EOT
1028 test_linkc "whether has getpid" "yes" "no" ""
1029 AC_DEFINE_UNQUOTED(CMK_HAS_GETPID, $pass, [whether getpid exists])
1030
1031 #### check if kill exists ####
1032 cat > $tc <<EOT
1033 #include <sys/types.h>
1034 #include <unistd.h>
1035 #include <signal.h>
1036
1037 int main(int argc, char**argv) 
1038 {
1039     pid_t pid = getpid();
1040     kill(pid, 9);
1041 }
1042 EOT
1043 test_linkc "whether has kill" "yes" "no" ""
1044 AC_DEFINE_UNQUOTED(CMK_HAS_KILL, $pass, [whether kill exists])
1045
1046 #### test for setpriority ###
1047 cat > $t <<EOT
1048 #include <sys/time.h>
1049 #include <sys/resource.h>
1050 void foo(void) { 
1051   setpriority(PRIO_PROCESS, 0, 0);
1052 }
1053 EOT
1054 test_cxx "whether has setpriority" "yes" "no" ""
1055 AC_DEFINE_UNQUOTED(CMK_HAS_SETPRIORITY, $pass, [whether the setpriority exists])
1056
1057 #### test for system ###
1058 cat > $t <<EOT
1059 #include "ckdll_system.C"
1060 EOT
1061 test_cxx "whether to use signal-safe system() " "yes" "no" ""
1062 AC_DEFINE_UNQUOTED(CMK_SIGSAFE_SYSTEM, $pass, [whether to use signal-safe system()])
1063
1064 ### test sched_setaffinity ####
1065 cat > $tc <<EOT
1066 #include <stdlib.h>
1067 #include <stdio.h>
1068 #include <unistd.h>
1069
1070 #define _GNU_SOURCE
1071 #include <sched.h>
1072 long sched_setaffinity(pid_t pid, unsigned int len, unsigned long *user_mask_ptr);
1073 long sched_getaffinity(pid_t pid, unsigned int len, unsigned long *user_mask_ptr);
1074
1075 int main()
1076 {
1077   unsigned long mask = 0xffffffff;
1078   unsigned int len = sizeof(mask);
1079
1080   if (sched_setaffinity(0, len, &mask) < 0) {
1081     return -1;
1082   }
1083   return 0;
1084 }
1085 EOT
1086 test_linkc "whether sched_setaffinity call exists" "yes" "no" ""
1087 AC_DEFINE_UNQUOTED(CMK_HAS_SETAFFINITY, $pass, [whether the sched_setaffinity() exists])
1088
1089 ### test pthread_setaffinity_np ####
1090 cat > $tc <<EOT
1091 #include <stdlib.h>
1092 #include <stdio.h>
1093 #include <unistd.h>
1094 #include <pthread.h>
1095
1096 int main()
1097 {
1098   unsigned long mask = 0xffffffff;
1099   unsigned int len = sizeof(mask);
1100
1101   if (pthread_setaffinity_np(pthread_self(), len, &mask) < 0) {
1102     return -1;
1103   }
1104   return 0;
1105 }
1106 EOT
1107 test_linkc "whether pthread_setaffinity_np call exists" "yes" "no" "-lpthread"
1108 AC_DEFINE_UNQUOTED(CMK_HAS_PTHREAD_SETAFFINITY, $pass, [whether the pthread_setaffinity_np() exists])
1109
1110
1111 ### check libnuma on Linux ####
1112 if test "$WITH_NUMA" = "yes"
1113 then
1114 cat > $tc <<EOT
1115 #include <stdlib.h>
1116 #include <stdio.h>
1117 #include <linux/mempolicy.h>
1118 #include <numaif.h>
1119 #include <numa.h>
1120
1121 int main()
1122 {
1123   if (get_mempolicy(NULL, NULL, 0, 0, 0) == 0) return 0;
1124   return -1;
1125 }
1126 EOT
1127 test_linkc "whether libnuma exists" "yes" "no" "-lnuma"
1128 AC_DEFINE_UNQUOTED(CMK_HAS_NUMACTRL, $pass, [whether NUMA control related functions exist])
1129 if test $pass -eq 1
1130 then
1131         add_flag 'CMK_SYSLIBS="$CMK_SYSLIBS -lnuma"' "libnuma"
1132 fi
1133 fi
1134
1135 #### check bindprocessors on AIX ####
1136 cat > $tc <<EOT
1137 #include <stdlib.h>
1138 #include <stdio.h>
1139 #include <unistd.h>
1140
1141 #include <sys/processor.h>
1142
1143 int main()
1144 {
1145   int retValue = 0;
1146   int pid;
1147   pid = getpid();
1148   if (bindprocessor(BINDPROCESS, pid, 0) == -1) return -1;
1149   return 0;
1150 }
1151 EOT
1152 test_linkc "whether bindprocessor call exists" "yes" "no" ""
1153 AC_DEFINE_UNQUOTED(CMK_HAS_BINDPROCESSOR, $pass, [whether the bindprocessor()
1154 exists])
1155
1156
1157 #### check if dlopen works ####
1158 skip_dl=0
1159 # for bproc, ignore -ldl
1160 test -n "$CMK_BPROC" && skip_dl=1
1161 test -n "$CMK_NO_DL" && skip_dl=1
1162 dl_opt='-ldl'
1163 #workaround for pgcc 4.0, -ldl crash linking, so use -Wl,-ldl to skip the prelinker.
1164 case "$CMK_CXX" in
1165 pgCC*) dl_opt='-Wl,-ldl' ;;
1166 esac
1167
1168 if test $skip_dl -eq 0 
1169 then
1170
1171 cat > $t <<EOT
1172 #include "ckdll_dlopen.C"
1173 int main() {
1174         CkDll dll("foo.so");
1175         return 0;
1176 }
1177 EOT
1178 test_link "whether dlopen links without $dl_opt" "yes" "no" ""
1179 noldl=$pass
1180 test_link "whether dlopen links with $dl_opt" "yes" "no" "$dl_opt"
1181 if test $pass -eq 1
1182 then 
1183 #dlopen requires -ldl: add it to our link line
1184         add_flag CMK_LIBS='"$CMK_LIBS '$dl_opt'"' "dlopen"
1185 fi
1186
1187 if test $pass -eq 1 -o $noldl -eq 1
1188 then
1189 # One version or another of dlopen worked: compile it in
1190         AC_DEFINE_UNQUOTED(CMK_DLL_USE_DLOPEN, 1, [dlopen])
1191 fi
1192
1193 ### test gethostname ####
1194 cat > $tc <<EOT
1195 #ifdef WIN32
1196 #include <Winsock2.h>
1197 #else
1198 #include <stdlib.h>
1199 #include <stdio.h>
1200 #include <unistd.h>
1201 #endif
1202
1203 int main()
1204 {
1205   char hostname[[1000]];
1206   gethostname(hostname, 999);
1207   return 0;
1208 }
1209 EOT
1210 test_linkc "whether gethostname call exists" "yes" "no" ""
1211 AC_DEFINE_UNQUOTED(CMK_HAS_GETHOSTNAME, $pass, [whether gethostname() exists])
1212
1213 #### check if getProcAddress works ####
1214 cat > $t <<EOT
1215 #include "ckdll_win32.C"
1216 EOT
1217 test_cxx "whether getProcAddress works" "yes" "no" ""
1218 AC_DEFINE_UNQUOTED(CMK_DLL_USE_WIN32, $pass, [whether getProcAddress works])
1219
1220 fi    # end of skip_dl
1221
1222 #### check if socklen_t exists ####
1223 cat > $t <<EOT
1224 #include <sys/types.h>
1225 #include <sys/socket.h>
1226
1227 void foo(void) {
1228         int i;
1229         socklen_t s=sizeof(i);
1230 }
1231 EOT
1232 test_cxx "whether has socklen_t" "yes" "no" ""
1233 AC_DEFINE_UNQUOTED(CMK_HAS_SOCKLEN, $pass, [whether has socklen_t])
1234
1235 ### test getifaddrs ####
1236 cat > $tc <<EOT
1237 #include <netinet/in.h> /* for sockaddr_in */
1238 #include <ifaddrs.h> /* for getifaddrs */
1239 #include <net/if.h> /* for IFF_RUNNING */
1240
1241 int main()
1242 {
1243   struct ifaddrs *interfaces=0;
1244   if( getifaddrs(&interfaces) == 0 ) {
1245         struct ifaddrs *interface;
1246         for( interface=interfaces; interface; interface=interface->ifa_next ) {
1247             if( (interface->ifa_flags & IFF_UP) && ! (interface->ifa_flags & IFF_LOOPBACK) ) {
1248                 const struct sockaddr_in *addr = (const struct sockaddr_in*)interface->ifa_addr;
1249                 if( addr && addr->sin_family==AF_INET ) {
1250                     break;
1251                 }
1252             }
1253         }
1254         freeifaddrs(interfaces);
1255   }
1256 }
1257 EOT
1258 test_linkc "whether getifaddrs call exists" "yes" "no" ""
1259 AC_DEFINE_UNQUOTED(CMK_HAS_GETIFADDRS, $pass, [whether getifaddrs() exists])
1260
1261 #### check if mmap exists ####
1262 cat > $t <<EOT
1263 #include <sys/types.h>
1264 #include <sys/mman.h>
1265
1266 void *foo(void *a,int l,int fd) {
1267         return mmap((caddr_t)a,l,PROT_READ+PROT_WRITE,
1268                  MAP_FIXED+MAP_PRIVATE,fd,0);
1269 }
1270 EOT
1271 test_cxx "whether the mmap() syscall exists" "yes" "no" ""
1272 AC_DEFINE_UNQUOTED(CMK_HAS_MMAP, $pass, [whether the mmap() syscall exists])
1273
1274 #### check if mmap accepts MAP_ANON ####
1275 cat > $t <<EOT
1276 #include <sys/types.h>
1277 #include <sys/mman.h>
1278
1279 void *foo(void *a,int l) {
1280         return mmap((caddr_t)a,l,PROT_READ+PROT_WRITE,
1281                 MAP_FIXED+MAP_PRIVATE+MAP_ANON,-1,0);
1282 }
1283 EOT
1284 test_cxx "whether mmap() accepts MAP_ANON" "yes" "no" ""
1285 AC_DEFINE_UNQUOTED(CMK_HAS_MMAP_ANON, $pass, [whether mmap() accepts MAP_ANON])
1286
1287 #### check if mmap accepts MAP_NORESERVE ####
1288 cat > $t <<EOT
1289 #include <sys/types.h>
1290 #include <sys/mman.h>
1291
1292 void *foo(void *a,int l) {
1293         return mmap((caddr_t)a,l,PROT_READ+PROT_WRITE,
1294                 MAP_FIXED+MAP_PRIVATE+MAP_NORESERVE,-1,0);
1295 }
1296 EOT
1297 test_cxx "whether mmap() accepts MAP_NORESERVE" "yes" "no" ""
1298 AC_DEFINE_UNQUOTED(CMK_HAS_MMAP_NORESERVE, $pass, [whether mmap() accepts MAP_NORESERVE])
1299
1300 #### check if get_myaddress exists ####
1301 cat > $t <<EOT
1302 #include <rpc/rpc.h>
1303
1304 void foo(void *a) {
1305     get_myaddress((struct sockaddr_in*)a);
1306 }
1307 EOT
1308 test_cxx "whether get_myaddress() exists" "yes" "no" ""
1309 AC_DEFINE_UNQUOTED(CMK_HAS_GET_MYADDRESS, $pass, [whether get_myaddress() exists])
1310
1311 #### check if glibc backtrace exists ####
1312 cat > $t <<EOT
1313 #include "cmibacktrace.c"
1314
1315 int main() {
1316         int nLevels=1;
1317         void *stack;
1318         CmiBacktraceRecord(&stack,0,&nLevels);
1319         return 0;
1320 }
1321 EOT
1322 TRACE_LINK_FLAG="-rdynamic"
1323 test_link "whether glibc backtrace works" "yes" "no" "-DCMK_USE_BACKTRACE=1 $TRACE_LINK_FLAG"
1324 AC_DEFINE_UNQUOTED(CMK_USE_BACKTRACE, $pass, [whether glibc backtrace works])
1325
1326 if test $strictpass -eq 1
1327 then 
1328         add_flag 'CMK_LD="$CMK_LD '$TRACE_LINK_FLAG'"' "backtrace"
1329         add_flag 'CMK_LDXX="$CMK_LDXX '$TRACE_LINK_FLAG'"' "backtrace"
1330 fi
1331
1332 #### test sleep ####
1333 cat > $t <<EOT
1334 #include <unistd.h>
1335 int main() {
1336   sleep(1);
1337   return 0;
1338 }
1339 EOT
1340 test_cxx "whether has sleep " "yes" "no" ""
1341 AC_DEFINE_UNQUOTED(CMK_HAS_SLEEP, $pass, [whether has sleep])
1342
1343 #### test usleep ####
1344 cat > $t <<EOT
1345 #include <unistd.h>
1346 int main() {
1347   usleep(100);
1348   return 0;
1349 }
1350 EOT
1351 test_cxx "whether has usleep " "yes" "no" ""
1352 AC_DEFINE_UNQUOTED(CMK_HAS_USLEEP, $pass, [whether has usleep])
1353
1354 #### test personality() and ADDR_NO_RANDOMIZE ####
1355 # Only works on modern Linux systems
1356 cat > $t <<EOT
1357 #include <sys/personality.h>
1358 int main() {
1359     int orig_persona = personality(0xffffffff);
1360     personality(orig_persona | ADDR_NO_RANDOMIZE);
1361     return 0;
1362 }
1363 EOT
1364 test_cxx "whether personality() and ADDR_NO_RANDOMIZE exist" "yes" "no" ""
1365 AC_DEFINE_UNQUOTED(CMK_HAS_ADDR_NO_RANDOMIZE, $pass, [whether personality() and ADDR_NO_RANDOMIZE exist])
1366
1367
1368 #### test if has zlib ####
1369 # bproc doesnot like -lz in any case
1370 if test -z "$CMK_BPROC"
1371 then
1372
1373 cat > $t <<EOT
1374 #include <zlib.h>
1375 int main() { 
1376   gzFile f = gzopen("/tmp/x","r");
1377   gzprintf(f, "test...\n");
1378   gzclose(f);
1379   return 0;
1380 }
1381 EOT
1382 test_link "whether has zlib" "yes" "no" "-lz"
1383 AC_DEFINE_UNQUOTED(CMK_PROJECTIONS_USE_ZLIB, $pass, [whether has zlib])
1384 if test $pass -eq 1
1385 then 
1386         add_flag 'CMK_LIBZ="-lz"' "zlib"
1387 fi
1388
1389 fi
1390
1391 #### test if has elf.h ####
1392 cat > $t <<EOT
1393 #include <elf.h>
1394 typedef Elf32_Addr ELF_TYPE_Addr;
1395 int main() { 
1396 }
1397 EOT
1398 test_cxx "whether has elf.h " "yes" "no" ""
1399 AC_DEFINE_UNQUOTED([CMK_HAS_ELF_H], $pass, [whether has elf.h])
1400
1401 #### test if has Multiprocessing.h for apple ####
1402 cat > $t <<EOT
1403 #include <Carbon/Carbon.h>
1404 #include <Multiprocessing.h>
1405 int main() {
1406   int a = MPProcessorsScheduled();
1407 }
1408 EOT
1409 test_cxx "whether has Multiprocessing.h for Apple " "yes" "no" ""
1410 AC_DEFINE_UNQUOTED([CMK_HAS_MULTIPROCESSING_H], $pass, [whether has Multiprocessing.h])
1411
1412 #### test if "ntohl" is available ####
1413 cat > $t <<EOT
1414 #if defined(_WIN32) && ! defined(__CYGWIN__) || defined(__MINGW_H)
1415 #include <winsock.h>
1416 #else
1417 #include <netinet/in.h>
1418 #include <arpa/inet.h>
1419 #endif
1420
1421 int main() {
1422   int i = 100;
1423   i = ntohl(i);
1424   return 0;
1425 }
1426 EOT
1427 test_link "whether ntohl is available" "yes" "no" ""
1428 AC_DEFINE_UNQUOTED(CMK_HAS_NTOHL, $pass, [whether ntohl is available])
1429
1430 ### test for libjpeg ####
1431 cat > $t <<EOT
1432 #include <stdio.h>
1433 #include <stdlib.h>
1434 #include "jpeglib.h"
1435
1436 int main()
1437 {
1438   struct jpeg_compress_struct cinfo;
1439   jpeg_create_compress(&cinfo);
1440   return 0;
1441 }
1442 EOT
1443 test_link "whether has libjpeg" "yes" "no" "-ljpeg"
1444 AC_DEFINE_UNQUOTED(CMK_USE_LIBJPEG, $pass, [whether has libjpeg])
1445 if test $pass -eq 1
1446 then
1447         add_flag 'CMK_LIBJPEG="-ljpeg"' "libjpeg"
1448 fi
1449
1450 #### check if PAPI exists ####
1451 if test -n "$CMK_USE_PAPI"
1452 then
1453 cat > $t <<EOT
1454 #include <stdio.h>
1455 #include <papi.h>
1456                                                                                 
1457 int main() {
1458     int Events[[1]] = { PAPI_TOT_CYC };
1459     if (PAPI_start_counters(Events, 1) != PAPI_OK) return 1;
1460     return 0;
1461 }
1462 EOT
1463 test_link "whether PAPI exists" "yes" "no" "-lpapi"
1464 AC_DEFINE_UNQUOTED(CMK_HAS_COUNTER_PAPI, $pass, [whether PAPI exists])
1465 if test $pass -eq 1
1466 then 
1467         add_flag 'CMK_LIBS="$CMK_LIBS -lpapi"' "papi"
1468 fi
1469 fi
1470
1471 #### test if Python headers are installed ####
1472 PYTHON_VERSION=`python -V 2>&1 | awk {'print $2'} | awk -F. {'print $1"."$2'}`
1473 cat > $t <<EOT
1474 #include "python${PYTHON_VERSION}/Python.h"
1475 #include "python${PYTHON_VERSION}/compile.h"
1476 #include "python${PYTHON_VERSION}/eval.h"
1477 #include "python${PYTHON_VERSION}/node.h"
1478
1479 int main() {
1480     Py_Initialize();
1481     PyEval_InitThreads();
1482     struct _node* programNode = PyParser_SimpleParseString("return 1\n",Py_file_input);
1483     PyCodeObject *program = PyNode_Compile(programNode, "");
1484 }
1485 EOT
1486 test_link "whether Python is installed" "yes" "no" "-lpython$PYTHON_VERSION -lpthread -lutil -ldl"
1487 AC_DEFINE_UNQUOTED(CMK_HAS_PYTHON, $pass, [whether Python is installed])
1488 AC_DEFINE_UNQUOTED(CMK_PYTHON_VERSION, ${PYTHON_VERSION}, [Python version])
1489 if test $pass -eq 1
1490 then
1491         add_flag "CMK_BUILD_PYTHON=$PYTHON_VERSION" "python"
1492 fi
1493
1494 #### test if it can build shared library ####
1495 cat > $t <<EOT
1496 #include "stdlib.h"
1497 extern int foo();
1498 int foo1() { 
1499   void * t= malloc(2);
1500   foo();
1501   return 0;
1502 }
1503 EOT
1504 test_linkso "whether can build shared library" "yes" "no" ""
1505 if test $pass -eq 0
1506 then 
1507         add_flag 'CMK_NO_BUILD_SHARED="true"' "build-shared"
1508 else
1509         BUILD_SHARED=1
1510         if test "$BUILD_MPI" = "1"
1511         then
1512 cat > $t <<EOT
1513 #include "stdlib.h"
1514 #include "mpi.h"
1515 extern int foo();
1516 int foo(int argc, char ** argv) {
1517   void * t= malloc(2);
1518   foo();
1519   MPI_Init(&argc, &argv);
1520   return 0;
1521 }
1522 EOT
1523                 test_linkso "whether can build shared library with MPI" "yes" "no" ""
1524                 BUILD_SHARED=$pass
1525         fi
1526         if test $BUILD_SHARED -eq 1
1527         then
1528                 add_flag 'CMK_NO_BUILD_SHARED="false"' "build-shared"
1529         else
1530                 add_flag 'CMK_NO_BUILD_SHARED="true"' "build-shared"
1531         fi
1532 fi
1533
1534 #### test the version number of bproc ####
1535 if test -n "$CMK_BPROC"
1536 then
1537 cat > $t <<EOT
1538 #include <stdio.h>
1539 #include <sys/bproc.h>
1540 int main()
1541 {
1542   struct bproc_version_t vers;
1543   bproc_version(&vers);
1544   printf("%s\n", vers.version_string);
1545 }
1546 EOT
1547 test_link "whether bproc compiles" "yes" "no" "-lbproc"
1548 if test $pass -eq 1
1549 then 
1550 AC_MSG_CHECKING("bproc version")
1551 bproc_ver=`./testlink`
1552 if test x$bproc_ver = x
1553 then
1554 test_result 0 "bproc version" "ERROR" ""
1555 test_finish 1
1556 else
1557 test_result 0 "bproc version" "$bproc_ver" ""
1558 fi
1559 bproc_ver=`echo $bproc_ver | cut -d'.' -f1`
1560 AC_DEFINE_UNQUOTED(CMK_BPROC_VERSION, $bproc_ver, [bproc version])
1561 fi
1562 fi
1563
1564 #### test the if command sync exists ####
1565 AC_CHECK_PROG(SYNC, sync, sync )
1566 if test -n "$SYNC"
1567 then
1568 AC_DEFINE_UNQUOTED(CMK_HAS_SYNC, 1, [sync program])
1569 fi
1570
1571 ################## Fortran #########################
1572
1573 #echo "set F77 compiler as: $CMK_CF77"
1574 AC_MSG_CHECKING("F77 compiler as")
1575 AC_MSG_RESULT("$CMK_CF77")
1576
1577 AC_MSG_CHECKING("whether Fortran 77 compiler works")
1578 ### test fortran 77 compiler ###
1579 cat > conftest.f <<EOF
1580       SUBROUTINE FOO_foo
1581       END
1582 EOF
1583 $CMK_CF77 -c conftest.f > /dev/null 2> /dev/null
1584 if test ! -r conftest.o
1585 then
1586   AC_MSG_RESULT("no")
1587 else
1588   AC_MSG_RESULT("yes")
1589 fi
1590
1591 ### test fortran 90 compiler ###
1592 #echo "set F90 compiler as: $CMK_CF90"
1593 AC_MSG_CHECKING("F90 compiler as")
1594 AC_MSG_RESULT("$CMK_CF90")
1595
1596 AC_MSG_CHECKING("whether Fortran 90 compiler works")
1597 cat > conftest2.f90 <<EOF
1598       SUBROUTINE FOO_foo
1599       END
1600 EOF
1601 $CMK_CF90 -c conftest2.f90 > /dev/null 2> /dev/null
1602 if test ! -r conftest2.o
1603 then
1604   AC_MSG_RESULT("no")
1605 else
1606   AC_MSG_RESULT("yes")
1607   mv -f conftest2.o conftest.o
1608   USE_FORTRAN90=1
1609 fi
1610
1611 ### check fortran name mangling
1612 AC_MSG_CHECKING(subroutine name used by Fortran 90 compiler)
1613
1614 if test -r conftest.o
1615 then
1616   AC_CACHE_VAL(_cv_fortran_postfix,
1617
1618   NAME=`$CMK_NM conftest.o | grep "foo_foo__"`
1619   if test "$NAME" != ""
1620   then
1621     _cv_fortran_postfix=TWOSCORE
1622     AC_DEFINE_UNQUOTED(CMK_FORTRAN_USES_TWOSCORE, 1, [TWOSCORE])
1623   else
1624     NAME=`$CMK_NM conftest.o | grep "foo_foo_"`
1625     if test "$NAME" != ""
1626     then
1627       _cv_fortran_postfix=ONESCORE
1628       AC_DEFINE_UNQUOTED(CMK_FORTRAN_USES_ONESCORE, 1, [ONESCORE])
1629     else
1630       NAME=`$CMK_NM conftest.o | grep "foo_foo"`
1631       if test "$NAME" != ""
1632       then
1633         _cv_fortran_postfix=NOSCORE
1634         AC_DEFINE_UNQUOTED(CMK_FORTRAN_USES_NOSCORE, 1, [NOSCORE])
1635       else
1636         NAME=`$CMK_NM conftest.o | grep "FOO_FOO"`
1637         if test "$NAME" != ""
1638         then
1639           _cv_fortran_postfix=ALLCAPS
1640           AC_DEFINE_UNQUOTED(CMK_FORTRAN_USES_ALLCAPS, 1, [ALLCAPS])
1641         else
1642           echo "#################################################"
1643           echo "FORTRAN compiler generated name not supported yet"
1644           echo "#################################################"
1645         fi
1646       fi
1647     fi
1648   fi
1649   rm -f conftest.f conftest.o
1650   )
1651   AC_MSG_RESULT($_cv_fortran_postfix)
1652 else
1653   AC_MSG_RESULT("Fortran compiler not working")
1654 fi
1655
1656 ### check module name ###
1657
1658 if test "$USE_FORTRAN90" = 1
1659 then
1660   cat > conftest.f90 <<EOF
1661       MODULE testmod
1662         interface 
1663           function fpup_issizing(p)
1664           INTEGER :: p
1665           logical fpup_issizing
1666           end function
1667         end interface
1668       END MODULE
1669 EOF
1670   AC_MSG_CHECKING(Fortran 90 mod name is capital)
1671   $CMK_CF90 -c conftest.f90 > /dev/null 2> /dev/null
1672   name=`ls TESTMOD.* 2>/dev/null`
1673   if test -n "$name"
1674   then
1675         AC_MSG_RESULT("yes")
1676         add_flag 'CMK_MOD_NAME_ALLCAPS=1' "mod name capital"
1677   else
1678         AC_MSG_RESULT("no")
1679         name=`ls testmod.* 2>/dev/null`
1680   fi
1681   if test -n "$name"
1682   then
1683         AC_MSG_CHECKING(Fortran 90 mod name extension)
1684         ext=`echo $name | sed -e 's/^[[^.]]*\.//'`
1685         add_flag 'CMK_MOD_EXT="'$ext'"' "mod name extension"
1686         AC_MSG_RESULT("$ext")
1687         /bin/rm -f $name
1688   fi
1689   /bin/rm -f conftest.f90
1690 fi
1691
1692 AC_OUTPUT(
1693 libs/ck-libs/ampi/ampiCC libs/ck-libs/ampi/ampirun,
1694
1695 chmod +x libs/ck-libs/ampi/ampiCC libs/ck-libs/ampi/ampirun
1696 )