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