configure: Force XL C/C++ to complain about variadic templates during
[charm.git] / src / scripts / configure.in
1
2 AC_INIT(./Makefile)
3
4 AC_CONFIG_HEADER(conv-autoconfig.h)
5
6 AC_CONFIG_COMMANDS([config-cleanup],
7                    [sed -i -e 's:^#define\s\+PACKAGE://&:' conv-autoconfig.h])
8
9 CHARMINC="."
10 CHARMBIN="../bin"
11 test -r ./conv-config.sh && . ./conv-config.sh
12
13 # Decimal representation of Charm++ release line and API revision
14 # Increment the last 2 digits when making an API change
15 # Increase the first three after branching for a release
16 VERSION=60601
17 echo $VERSION > ../include/VERSION
18 AC_DEFINE_UNQUOTED([CHARM_VERSION], $VERSION, [Charm++ Release/API version number])
19
20 charmout="charmconfig.out"
21 /bin/rm -rf $charmout
22 MAKEFILE_EXT=Make.extlib
23
24 Echo() {
25         echo $* 
26         echo $* >> $charmout
27 }
28
29 # add into conv-mach-opt.sh
30 # add_flag $1 $2
31 # $2 is description
32 add_flag() {
33         key=`echo $1 | cut -d'=' -f1`
34         last=`grep "$key=" ../include/conv-mach-opt.sh 2>/dev/null | tail -1 | sed -e 's/ *#.*$//'`
35         skip=0
36         if test -n "$last" -a  "$last" = "$1" 
37         then
38           skip=1
39         fi
40         if test $skip = 0
41         then
42           cat >> ../include/conv-mach-opt.sh << EOT
43
44 $1   # Option added by configure script's $2 section
45 EOT
46         fi
47 }
48
49 # remove_flag $1
50 remove_flag() {
51      sed -e '/^'"$1"'=/d' ../include/conv-mach-opt.sh > tmp.$$
52      cp tmp.$$ ../include/conv-mach-opt.sh
53      /bin/rm -f tmp.$$
54 }
55
56
57 #clean up conv-mach-opt.sh
58 sed -e '/Option added by configure/d' ../include/conv-mach-opt.sh  | sed -e '/^$/d' > conv-mach-opt.sh.clean
59 cp -f conv-mach-opt.sh.clean   ../include/conv-mach-opt.sh
60 rm -f conv-mach-opt.sh.clean
61
62
63 # enable/disable error checking
64 AC_ARG_ENABLE([error-checking],
65             [AS_HELP_STRING([--enable-error-checking],
66               [enable error checking])], ,
67             [enable_error_checking=yes])
68
69 if test "$enable_error_checking" = "no"
70 then
71   Echo "Error checking is disabled" 
72   AC_DEFINE_UNQUOTED(CMK_ERROR_CHECKING, 0, [disable error checking])
73   add_flag 'OPTS_CC="$OPTS_CC -U_FORTIFY_SOURCE"' 'error checking'
74   add_flag 'OPTS_CXX="$OPTS_CXX -U_FORTIFY_SOURCE"' 'error checking'
75 else
76   Echo "Error checking is enabled" 
77   AC_DEFINE_UNQUOTED(CMK_ERROR_CHECKING, 1, [enable error checking])
78 fi
79
80 # enable/disable statistics collection
81 AC_ARG_ENABLE([stats],
82             [AS_HELP_STRING([--enable-stats],
83               [enable statistics collection])], ,
84             [enable_stats=yes])
85
86 if test "$enable_stats" = "no"
87 then
88   Echo "Statistics collection is disabled" 
89   AC_DEFINE_UNQUOTED(CMK_WITH_STATS, 0, [disable statistics collection])
90 else
91   Echo "Statistics collection is enabled" 
92   AC_DEFINE_UNQUOTED(CMK_WITH_STATS, 1, [enable statistics collection])
93 fi
94
95 # check enable/disable
96 AC_ARG_ENABLE([tracing],
97             [AS_HELP_STRING([--enable-tracing],
98               [enable tracing modules])], ,
99             [enable_tracing=yes])
100
101 if test "$enable_tracing" = "no"
102 then
103   Echo "Charm tracing is disabled"
104   AC_DEFINE_UNQUOTED(CMK_TRACE_ENABLED, 0, [disable tracing])
105   add_flag CMK_TRACE_ENABLED=0
106 else
107   Echo "Charm tracing is enabled"
108   AC_DEFINE_UNQUOTED(CMK_TRACE_ENABLED, 1, [enable tracing])
109   add_flag CMK_TRACE_ENABLED=1
110 fi
111
112 AC_ARG_ENABLE([tracing-commthread],
113             [AS_HELP_STRING([--enable-tracing-commthread],
114               [enable tracing communication thread])], ,
115             [enable_tracing_commthread=no])
116
117 if test "$enable_tracing_commthread" = "yes"
118 then
119   Echo "Charm tracing communication thread is enabled"
120   AC_DEFINE_UNQUOTED(CMK_SMP_TRACE_COMMTHREAD, 1, [enable tracing comm thread])
121 else
122   Echo "Charm tracing communication thread is disabled"
123   AC_DEFINE_UNQUOTED(CMK_SMP_TRACE_COMMTHREAD, 0, [disable tracing comm thread])
124 fi
125
126
127 AC_ARG_ENABLE([charmdebug],
128             [AS_HELP_STRING([--enable-charmdebug],
129               [enable charmDebug])], ,
130             [enable_charmdebug=yes])
131
132 if test "$enable_charmdebug" = "no"
133 then
134   Echo "CharmDebug is disabled" 
135   AC_DEFINE_UNQUOTED(CMK_CHARMDEBUG, 0, [disable charmdebug])
136   add_flag CMK_CHARMDEBUG=0
137 else
138   Echo "CharmDebug is enabled" 
139   AC_DEFINE_UNQUOTED(CMK_CHARMDEBUG, 1, [enable charmdebug])
140   add_flag CMK_CHARMDEBUG=1
141 fi
142
143 AC_ARG_ENABLE([replay],
144             [AS_HELP_STRING([--enable-replay],
145               [enable record/replay])],
146             [enable_replay=$enableval],
147             [enable_replay=yes])
148
149 if test "$enable_replay" = "no"
150 then
151   Echo "Charm record/replay is disabled"
152   AC_DEFINE_UNQUOTED(CMK_REPLAYSYSTEM, 0, [disable replay])
153 else
154   Echo "Charm record/replay is enabled"
155 fi
156
157 AC_ARG_ENABLE([ccs],
158             [AS_HELP_STRING([--enable-ccs],
159               [enable CCS])], ,
160             [enable_ccs=yes])
161
162 if test "$enable_ccs" = "no"
163 then
164   Echo "CCS is disabled" 
165   AC_DEFINE_UNQUOTED(CMK_CCS_AVAILABLE, 0, [disable ccs])
166 else
167   Echo "CCS is enabled" 
168   AC_DEFINE_UNQUOTED(CMK_CCS_AVAILABLE, 1, [enable ccs])
169 fi
170
171 AC_ARG_ENABLE([controlpoint],
172             [AS_HELP_STRING([--enable-controlpoint],
173               [enable control point])],
174             [enable_controlpoint=$enableval],
175             [enable_controlpoint=yes])
176
177 if test "$enable_controlpoint" = "yes"
178 then
179   Echo "Charm control point is enabled"
180   AC_DEFINE_UNQUOTED(CMK_WITH_CONTROLPOINT, 1, [enable controlpoint])
181 else
182   Echo "Charm control point is disabled"
183   AC_DEFINE_UNQUOTED(CMK_WITH_CONTROLPOINT, 0, [disable controlpoint])
184 fi
185
186 AC_ARG_ENABLE([lbuserdata],
187             [AS_HELP_STRING([--enable-lbuserdata],
188               [enable LB user data])],
189             [enable_lbuserdata=$enableval],
190             [enable_lbuserdata=no])
191
192 if test "$enable_lbuserdata" = "yes"
193 then
194   Echo "Charm LB user data is enabled"
195   AC_DEFINE_UNQUOTED(CMK_LB_USER_DATA, 1, [enable lb user data])
196 else
197   Echo "Charm LB user data  is disabled"
198   AC_DEFINE_UNQUOTED(CMK_LB_USER_DATA, 0, [disable lb user data])
199 fi
200
201 AC_ARG_WITH([numa],
202             [AS_HELP_STRING([--with-numa],
203               [support memory affinity with NUMA])],
204             [],
205             [with_numa=no])
206
207 WITH_NUMA=no
208 if test "$with_numa" = "yes"
209 then
210   Echo "Charm NUMA support is builtin"
211   WITH_NUMA=yes
212 fi
213
214 AC_ARG_WITH([lbtime-type],
215             [AS_HELP_STRING([--with-lbtime-type=type],
216                             [load balancing timer type])],
217             [], [with_lbtime_type=double])
218
219 if test "$with_lbtime_type" = "float" -o "$with_lbtime_type" = "double"
220 then
221   Echo "Setting load balancing timer type as '$with_lbtime_type'"
222   AC_DEFINE_UNQUOTED(CMK_LBTIME_TYPE, $with_lbtime_type, [Setting load balancing timer type])
223 else
224   Echo "Invalid type specified for load balancing timer type"
225   test_finish 1
226 fi
227
228
229 #
230 AC_MSG_CHECKING(machine name)
231 version=`pwd | awk -F/ '{print $(NF-1)}'`
232 base_version=`cat .vdir`
233 AC_DEFINE_UNQUOTED(CMK_MACHINE_NAME, "$version",[machine name])
234 AC_MSG_RESULT($version)
235 AC_SUBST(base_version)
236
237 t="test.cpp"
238 tc="test.c"
239
240 # test result passed in $1
241 # If the test suceeded, print $3 and set "pass"/clear "fail"
242 # If the test failed, print $2 and clear "pass"/set "fail"
243 test_result() {
244         if test $1 -eq 0
245         then
246                 AC_MSG_RESULT("$3")
247                 pass="1"
248                 fail="0"
249         else
250                 AC_MSG_RESULT("$4")
251                 pass="0"
252                 fail="1"
253 # For debugging the configure script, just "export autoconf_debug=1"
254 #  to get this verbose data on any failed tests:
255                 if test ! -z "$autoconf_debug"
256                 then
257                         echo "------- test script for $2 failed:"
258                         cat out
259                         echo "------- the test program was:"
260                         cat $t
261                         echo "-------"
262                 fi
263         fi
264 }
265
266 # Test: tries to compile C file $t (described by $1).
267 #  If successful, prints $2 and sets $pass/clears $fail
268 #  If failure, prints $3 and sets $pass/clears $fail
269 #  additional arguments to c++ compiler are passed as $4
270 test_cc() {
271         AC_MSG_CHECKING("$1")
272         echo "### $1" >> $charmout
273         cat $tc >> $charmout
274         echo $CMK_CC -I../include -I. $CMK_LIBDIR $CMK_INCDIR $CMK_SYSINC $OPTS_CC $OPTS_LD -c $tc -o test.o $4 >> $charmout
275         $CMK_CC -I../include -I. $CMK_LIBDIR $CMK_INCDIR $CMK_SYSINC $OPTS_CC $OPTS_LD -c $tc -o test.o $4 > out 2>&1
276         test_result $? "$1" "$2" "$3"
277         strictpass=$pass
278         strictfail=$fail
279         if test $pass -eq 1
280         then 
281           if cat out | grep -i "warn" > /dev/null 2>&1
282           then 
283             strictpass="0" && strictfail="1"
284           fi
285         fi
286         cat out >> $charmout
287         /bin/rm -f out
288 }
289
290 # Test: tries to compile C++ file $t (described by $1).
291 #  If successful, prints $2 and sets $pass/clears $fail
292 #  If failure, prints $3 and sets $pass/clears $fail
293 #  additional arguments to c++ compiler are passed as $4
294 test_cxx() {
295         AC_MSG_CHECKING("$1")
296         echo "### $1" >> $charmout
297         cat $t >> $charmout
298         echo $CMK_CXX -I../include -I. $CMK_LIBDIR $CMK_INCDIR $CMK_SYSINC $OPTS_CXX $OPTS_LD -c $t -o test.o $4 >> $charmout
299         $CMK_CXX -I../include -I. $CMK_LIBDIR $CMK_INCDIR $CMK_SYSINC $OPTS_CXX $OPTS_LD -c $t -o test.o $4 > out 2>&1
300         test_result $? "$1" "$2" "$3"
301         strictpass=$pass
302         strictfail=$fail
303         if test $pass -eq 1
304         then 
305           if cat out | grep -i "warn" > /dev/null 2>&1
306           then 
307             strictpass="0" && strictfail="1"
308           fi
309         fi
310         cat out >> $charmout
311         /bin/rm -f out
312 }
313
314 # Testlink: tries to compile and link a C++ file $t (described by $1).
315 #  If successful, prints $2 and sets $pass/clears $fail
316 #  If failure, prints $3 and sets $pass/clears $fail
317 #  additional arguments to c++ compiler are passed as $4
318 test_link() {
319         AC_MSG_CHECKING("$1")
320         echo "### $1" >> $charmout
321         cat $t >> $charmout
322         echo $CMK_CXX -I../include -I. $CMK_INCDIR $CMK_SYSINC $OPTS_CXX -c $t -o test.o $4 >> $charmout
323         $CMK_CXX -I../include -I. $CMK_INCDIR $CMK_SYSINC $OPTS_CXX -c $t -o test.o $4 > out 2>&1
324         if test $? -ne 0
325         then
326           test_result 1 "$1" "$2" "$3"
327         else
328           echo $CMK_LDXX -o testlink test.o $CMK_LIBDIR $OPTS_LD $CMK_SYSLIBS $4 >> $charmout
329           $CMK_LDXX -o testlink test.o $CMK_LIBDIR $OPTS_LD $CMK_SYSLIBS $4 >> out 2>&1
330           ret=$?
331           test ! -x testlink && ret=1
332           test_result $ret "$1" "$2" "$3"
333         fi
334         strictpass=$pass
335         strictfail=$fail
336         if test $pass -eq 1
337         then 
338           if cat out | grep -i "warn" > /dev/null 2>&1
339           then 
340             strictpass="0" && strictfail="1"
341           fi
342         fi
343         cat out >> $charmout
344         /bin/rm -f out
345 }
346
347 # Testlinkc: tries to compile and link a C file $t (described by $1).
348 #  If successful, prints $2 and sets $pass/clears $fail
349 #  If failure, prints $3 and sets $pass/clears $fail
350 #  additional arguments to c++ compiler are passed as $4
351 test_linkc() {
352         AC_MSG_CHECKING("$1")
353         echo "### $1" >> $charmout
354         cat $tc >> $charmout
355         echo $CMK_CC -I../include -I. $CMK_INCDIR $CMK_SYSINC $OPTS_CC -c $tc -o test.o $4 >> $charmout
356         $CMK_CC -I../include -I. $CMK_INCDIR $CMK_SYSINC $OPTS_CC -c $tc -o test.o $4 > out 2>&1
357         if test $? -ne 0
358         then
359           test_result 1 "$1" "$2" "$3"
360         else
361           echo $CMK_LD -o testlink test.o $CMK_LIBDIR $OPTS_LD $CMK_SYSLIBS $4 >> $charmout
362           $CMK_LD -o testlink test.o $CMK_LIBDIR $OPTS_LD $CMK_SYSLIBS $4 >> out 2>&1
363           test_result $? "$1" "$2" "$3"
364         fi
365         strictpass=$pass
366         strictfail=$fail
367         if test $pass -eq 1
368         then 
369           if cat out | grep -i "warn" > /dev/null 2>&1
370           then 
371             strictpass="0" && strictfail="1"
372           fi
373         fi
374         cat out >> $charmout
375         /bin/rm -f out
376 }
377
378 # test_linkso $1 $2 $3 $4, where
379 # $1: debug msg
380 # $2: yes msg
381 # $3: no msg
382 # $4: extra link option
383 test_linkso() {
384         AC_MSG_CHECKING("$1")
385         echo $1 >> $charmout
386         cat $t >> $charmout
387         echo $CMK_CXX -I../include -I. $CMK_INCDIR $CMK_SYSINC $OPTS_CXX $CMK_PIC -c $t -o test.o $4 >> $charmout
388         $CMK_CXX -I../include -I. $CMK_INCDIR $CMK_SYSINC $OPTS_CXX -c $CMK_PIC $t -o test.o $4 > out 2>&1
389         if test $? = 1
390         then
391           test_result 1 "$1" "$2" "$3"
392         else
393           echo $CMK_LD -I../include -I. $CMK_LIBDIR $OPTS_LD $CMK_LD_SHARED $CMK_SYSLIBS test.o -o testlink.$CMK_SHARED_SUF $4 >> $charmout
394           $CMK_LD -I../include -I. $CMK_LIBDIR $OPTS_LD $CMK_LD_SHARED $CMK_SYSLIBS test.o -o testlink.$CMK_SHARED_SUF $4 > out 2>&1
395           test_result $? "$1" "$2" "$3"
396         fi
397         cat out >> $charmout
398         /bin/rm -f out testlink.$CMK_SHARED_SUF
399 }
400
401 test_finish() {
402         rm -f $t $tc testlink test.o    > /dev/null 2>&1
403         /bin/rm -f out
404         test $1 -eq 1 && echo "*** Please find detailed output in charmconfig.out ***"
405         exit $1
406 }
407
408 # detect certain architectures
409 if cat /proc/cpuinfo 2>/dev/null | grep 'POWER7'  > /dev/null
410 then
411   AC_DEFINE_UNQUOTED(CMK_POWER7, 1, [whether is power7])
412 fi
413
414 # detect OS
415 OSNAME=`uname -s`
416 if test $OSNAME = "Linux"
417 then
418   AC_DEFINE_UNQUOTED(CMK_OS_IS_LINUX, 1, [OS is Linux])
419 else
420   AC_DEFINE_UNQUOTED(CMK_OS_IS_LINUX, 0, [OS is Linux])
421 fi
422
423 # test cp -p
424 AC_MSG_CHECKING("cp command as")
425 CP="cp -p"
426 touch test_file
427 if ! $CP test_file test_file.cp 2>err
428 then
429   CP="cp"
430 fi
431 rm -f test_file test_file.cp
432 AC_MSG_RESULT($CP)
433 add_flag CP=\""$CP"\" "cp command"
434  
435
436 # try to decide the version of glibc
437 get_glibc_version() {
438 t=test.c
439 cat > $t <<EOT
440 #include <stdio.h>
441 #include <gnu/libc-version.h>
442 int main (void) { puts (gnu_get_libc_version ()); return 0; }
443 EOT
444 gcc -o gver test.c
445 GLIBCVERSION=`./gver`
446 /bin/rm -f $t gver
447 }
448
449 cat > $t <<EOT
450 #include <stdio.h>
451 void foo(void) {
452         printf("Hello, world!\n");
453 }
454 EOT
455
456 if test "$CMK_BUILD_CRAY" = "1"
457 then
458 #echo "Test for known incompatible compiler versions"
459
460  if test "$CRAY_CC_VERSION" = "8.1.4"
461  then
462         echo "CCE 8.1.4 produces incorrect Charm++ code"
463         echo "Please use a newer version of the CCE compiler"
464         echo "e.g. module load cce/8.1.7"
465         test_finish 1
466  fi
467 fi
468
469 #echo "set C++ compiler as: $CMK_CXX $OPTS_CXX $OPTS"
470 AC_MSG_CHECKING("C++ compiler as")
471 AC_MSG_RESULT("$CMK_CXX $OPTS_CXX")
472 test_cxx "whether C++ compiler works" "ok" "no" ""
473 if test $fail -eq 1
474 then
475         echo "Cannot compile C++ programs with $CMK_CXX"
476         echo " (check your charm++ version)"
477         test_finish 1
478 fi
479
480 cat > $t <<EOT
481 #include <stdio.h>
482 int main() {
483         printf("Hello, world!\n");
484         return 0;
485 }
486 EOT
487 #echo "set C++ linker as: $CMK_LDXX $OPTS_LDXX"
488 AC_MSG_CHECKING("C++ linker as")
489 AC_MSG_RESULT("$CMK_LDXX $OPTS_LDXX")
490 test_link "whether linker works" "ok" "no" ""
491 if test $fail -eq 1
492 then
493         echo "Cannot link C++ programs with $CMK_LDXX"
494         echo " (check your charm++ version)"
495         test_finish 1
496 fi
497
498 AC_MSG_CHECKING("Native C++ compiler as")
499 AC_MSG_RESULT("$CMK_NATIVE_CXX")
500 AC_MSG_CHECKING("Sequential C++ compiler as")
501 AC_MSG_RESULT("$CMK_SEQ_CXX")
502
503 if test "$base_version" = "net-linux" 
504 then
505   test_link "whether linker accept --allow-multiple-definition" "ok" "no" "-Wl,--allow-multiple-definition"
506   if test $pass -eq 1
507   then
508         remove_flag CMK_LDXX
509         add_flag CMK_LDXX='"$CMK_LDXX -Wl,--allow-multiple-definition"' "net-linux linker"
510   fi
511 fi
512
513 if echo "$CMK_CC" | grep -E "gcc|clang|icc" > /dev/null 2> /dev/null
514 then
515   test_link "whether compiler accept -fno-stack-protector" "ok" "no" "-fno-stack-protector"
516   if test $strictpass -eq 1
517   then
518         add_flag OPTS_CC='"$OPTS_CC -fno-stack-protector"' "stack-protection disabling"
519         add_flag OPTS_CXX='"$OPTS_CXX -fno-stack-protector"' "stack-protection disabling"
520   fi
521 fi
522
523 #### check if C++ compiler will accept early C++11 variadic templates without warning ####
524 cat > $t <<EOT
525 class CkMigrateMessage;
526
527 struct base { 
528   base(void) { }
529   base(CkMigrateMessage *) { }
530 };
531
532 template <class Parent>
533 struct CBaseT1 : Parent {
534
535   CBaseT1(void) :Parent()  { }
536   CBaseT1(CkMigrateMessage *m) :Parent(m) { }
537
538   template <typename... Args>
539     CBaseT1(Args... args) : Parent(args...) { }
540 };
541
542 template struct CBaseT1<base>;
543 EOT
544 got_cpp11=""
545 test_cxx "whether C++ compiler supports variadic templates without flags" "yes" "no" ""
546 if test $strictpass -eq 1
547 then
548   got_cpp11="true"
549 else
550 # Flags for g++/clang++, xlC++, and pgCC, respectively
551 for i in "-std=c++0x" "-qlanglvl=extended0x" "--c++11"; do
552     test_cxx "whether C++ compiler supports variadic templates with '$i'" "yes" "no" "$i"
553     if test $strictpass -eq 1
554     then
555       add_flag "$(echo OPTS_CXX=\"\$OPTS_CXX $i\")" "Enable C++11 support"
556       OPTS_CXX="$OPTS_CXX $i"
557       got_cpp11="true"
558       break
559     fi
560 done
561 fi
562
563 if test -z $got_cpp11
564 then
565   echo "Charm++ requires some C++11 support, but doesn't know the flag to enable it"
566   test_finish 1
567 fi
568
569 # Figure out if the user has asked to enable the latest language standards
570 USER_ASKED_FOR_NEW_STD=`echo "$BUILDOPTS" | grep "-use-new-std" | wc -l`
571
572 # If the user has asked for the newer standards, check if the compilers know about them
573 if test $USER_ASKED_FOR_NEW_STD -ge 1
574 then
575
576 #### check if c compiler supports c11 compilation flags ####
577 cat > $tc <<EOT
578 #include <stdio.h>
579
580 int foo()
581 {
582   return 0;
583 }
584 EOT
585 test_cc "whether c compiler knows of the c11 standard" "ok" "no" "$CMK_ENABLE_C11"
586 AC_DEFINE_UNQUOTED(CMK_COMPILER_KNOWS_C11, $pass, [whether c compiler knows of the c11 standard] )
587 if test $pass -eq 1
588 then
589         # Record results for charmc's future use
590         add_flag 'CMK_COMPILER_KNOWS_C11="1"' "c11"
591         # For the rest of configure, append this to compilation flags
592         OPTS_CC="$CMK_ENABLE_C11 $OPTS_CC"
593 fi
594
595 #### check if C++ compiler supports cpp11 compilation flags ####
596 cat > $t <<EOT
597 #include <iostream>
598
599 int foo()
600 {
601   return 0;
602 }
603 EOT
604 test_cxx "whether c++ compiler knows of the cpp11 standard" "ok" "no" "$CMK_ENABLE_CPP11"
605 AC_DEFINE_UNQUOTED(CMK_COMPILER_KNOWS_CPP11, $pass, [whether c++ compiler knows of the cpp11 standard] )
606 if test $pass -eq 1
607 then
608         # Record results for charmc's future use
609         add_flag 'CMK_COMPILER_KNOWS_CPP11="1"' "cpp11"
610         # For the rest of configure, append this to compilation flags
611         OPTS_CXX="$CMK_ENABLE_CPP11 $OPTS_CXX"
612 fi
613
614 fi # endif USER_ASKED_FOR_NEW_STD
615
616
617 # Perform the tests
618
619 AC_ARG_WITH([refnum-type],
620             [AS_HELP_STRING([--with-refnum-type=type],
621                             [size of the envelope refnum field])],
622             [], [with_refnum_type=no])
623
624 if test "$with_refnum_type" = "no" -o "$with_refnum_type" = "short"
625 then
626   Echo "Setting charm++ envelope refnum field to unsigned short"
627   AC_DEFINE_UNQUOTED(CMK_REFNUM_TYPE, unsigned short, [envelope refnum field set to UShort])
628 elif test "$with_refnum_type" = "int"
629 then
630   Echo "Setting charm++ envelope refnum field to unsigned int"
631   AC_DEFINE_UNQUOTED(CMK_REFNUM_TYPE, unsigned int, [envelope refnum field set to UInt])
632 else
633   Echo "Invalid size specified for refnum field"
634   test_finish 1
635 fi
636
637
638 AC_ARG_WITH([prio-type],
639             [AS_HELP_STRING([--with-prio-type=type],
640                             [size of expected message priorities])],
641             [], [with_prio_type=bitvec])
642
643 if test "$with_prio_type" = "char" -o "$with_prio_type" = "short" -o "$with_prio_type" = "int" -o "$with_prio_type" = "long" -o "$with_prio_type" = "float" -o "$with_prio_type" = "double"
644 then
645   Echo "Configuring support for message priorities of sizeof type $with_prio_type"
646   AC_DEFINE_UNQUOTED(CMK_USE_STL_MSGQ, 1, [whether charm scheduler should use an STL-based msg q])
647   AC_DEFINE_UNQUOTED(CMK_MSG_PRIO_TYPE, $with_prio_type, [expected message priorities are sizeof $with_prio_type])
648 elif test "$with_prio_type" = "bitvec"
649 then
650   Echo "Configuring support for message priorities of arbitrary size (bitvectors)"
651   AC_DEFINE_UNQUOTED(CMK_USE_STL_MSGQ, 0, [whether charm scheduler should use an STL-based msg q])
652   AC_DEFINE_UNQUOTED(CMK_MSG_PRIO_TYPE, $with_prio_type, [expected message priorities are arbitrarily sized])
653 else
654   Echo "Invalid size ($with_prio_type) specified for message priorities. Can only accept char, short, int, long, float, double and bitvec"
655   test_finish 1
656 fi
657
658 # enable/disable randomized scheduler queue
659 AC_ARG_ENABLE([randomized-msgq],
660             [AS_HELP_STRING([--enable-randomized-msgq],
661               [enable a randomized msg queue (for debugging etc)])], ,
662             [enable_randomized_msgq=no])
663
664 if test "$enable_randomized_msgq" = "yes" -a "$with_prio_type" != "bitvec"
665 then
666   Echo "The charm message queue will be randomized (and will not respect priorities)"
667   AC_DEFINE_UNQUOTED(CMK_RANDOMIZED_MSGQ, 1, [enable the randomized msgq in the scheduler])
668 else
669   AC_DEFINE_UNQUOTED(CMK_RANDOMIZED_MSGQ, 0, [disable the randomized msgq in the scheduler])
670   if test "$enable_randomized_msgq" = "yes"
671   then
672     Echo 'A randomized message queue is only available when --with-prio-type != bitvec.'
673     Echo "Specify prio-type to be a data type long enough to hold the message priorities in your application"
674     Echo "for example: --with-prio-type=int (or short / long etc)."
675     test_finish 1
676   fi
677 fi
678
679 #### Check if compiler if 64 bit ####
680 cat > $t <<EOT
681 #include <stdio.h>
682
683 int foo()
684 {
685 int x[[(int)(sizeof(void *) - 7)]]={0};
686 return x[[0]];
687 }
688 EOT
689 test_cxx "whether compiler generates code for 64-bit" "yes" "no" ""
690 AC_DEFINE_UNQUOTED(CMK_SIZET_64BIT, $strictpass, [whether size_t 64bit])
691 in64bit=$strictpass
692
693
694 ### Check if compiler supports std::alignment_of<> ###
695 cat > $t <<EOT
696 #include <type_traits>
697
698 int foo()
699 {
700   return std::alignment_of<int>::value;
701 }
702 EOT
703 test_cxx "whether compiler supports std::alignment_of" "yes" "no" ""
704 AC_DEFINE_UNQUOTED(CMK_HAS_ALIGNMENT_OF, $strictpass, [whether compiler supports std::alignment_of])
705
706
707 #### test if has values.h ####
708 cat > $t <<EOT
709 #include <values.h>
710 int main() { 
711   double d = MAXDOUBLE;
712   return 0;
713 }
714 EOT
715 test_cxx "whether has values.h " "yes" "no" ""
716 AC_DEFINE_UNQUOTED(CMK_HAS_VALUES_H, $pass, [whether has values.h])
717
718 #### test if has stdint.h ####
719 cat > $t <<EOT
720 #include <stdint.h>
721 int main() { 
722   return 0;
723 }
724 EOT
725 test_cxx "whether has stdint.h " "yes" "no" ""
726 AC_DEFINE_UNQUOTED(CMK_HAS_STDINT_H, $pass, [whether has stdint.h])
727
728 #### test if has malloc.h ####
729 cat > $t <<EOT
730 #include <malloc.h>
731 int main() { 
732   return 0;
733 }
734 EOT
735 test_cxx "whether has malloc.h " "yes" "no" ""
736 AC_DEFINE_UNQUOTED(CMK_HAS_MALLOC_H, $pass, [whether has malloc.h])
737
738 #### test if has alloca.h ####
739 cat > $t <<EOT
740 #include <alloca.h>
741 int main() {
742   double *s=(double *)alloca(sizeof(double));
743   *s=1.0;
744   return 0;
745 }
746 EOT
747 test_cxx "whether has alloca.h " "yes" "no" ""
748 AC_DEFINE_UNQUOTED(CMK_HAS_ALLOCA_H, $pass, [whether has alloca.h])
749
750 #### test if has regex.h ####
751 cat > $t <<EOT
752 #include <regex.h>
753 int main() {
754   regex_t re;
755   regcomp(&re, ".*MOD.*", REG_EXTENDED|REG_NOSUB);
756   return 0;
757 }
758 EOT
759 test_cxx "whether has regex.h " "yes" "no" ""
760 AC_DEFINE_UNQUOTED(CMK_HAS_REGEX_H, $pass, [whether has regex.h])
761
762 #### Check long long ####
763 cat > $t <<EOT
764 #include <stdlib.h>
765 long long foo(void) { return 17; }
766 EOT
767 test_cxx "whether long long works" "yes" "no" ""
768 AC_DEFINE_UNQUOTED(CMK_LONG_LONG_DEFINED, $pass, [whether long long works])
769
770 #### Check __int64 ####
771 cat > $t <<EOT
772 #include <stdlib.h>
773 __int64 foo(void) { return 17; }
774 EOT
775 test_cxx "whether __int64 works" "yes" "no" ""
776 AC_DEFINE_UNQUOTED([CMK___int64_DEFINED], $pass, [whether __int64 works])
777
778 #### Check __int128 ####
779 cat > $t <<EOT
780 #include <stdlib.h>
781 int foo(void) {
782   __int128   a;
783   int x[[(int)(sizeof(__int128) - 15)]]={0};
784   return x[[0]];
785 }
786 EOT
787 test_cxx "whether __int128 (128-bit integer) works" "yes" "no" ""
788 AC_DEFINE_UNQUOTED([CMK___int128_DEFINED], $pass, [whether __int128 works])
789 if test $pass -eq 1
790 then
791   add_flag CMK_HAS_INT16=1
792 fi
793
794 #### Check __int128_t ####
795 cat > $t <<EOT
796 #include <stdlib.h>
797 int foo(void) {
798   __int128_t   a;
799   __uint128_t   b;
800   int x[[(int)(sizeof(__int128_t) - 15)]]={0};
801   return x[[0]];
802 }
803 EOT
804 test_cxx "whether __int128_t (128-bit integer) works" "yes" "no" ""
805 AC_DEFINE_UNQUOTED([CMK___int128_t_DEFINED], $pass, [whether __int128_t works])
806 if test $pass -eq 1
807 then
808   add_flag CMK_HAS_INT16=1
809 fi
810
811 #### Check long double ####
812 cat > $t <<EOT
813 #include <stdlib.h>
814 long double foo(void) { return 17.0; }
815 EOT
816 test_cxx "whether long double works" "yes" "no" ""
817 AC_DEFINE_UNQUOTED(CMK_LONG_DOUBLE_DEFINED, $strictpass, [whether long double works])
818
819 #### Check ucontext and FPU pointer ####
820 cat > $t <<EOT
821 #include <ucontext.h>
822 struct _libc_fpstate   fpstate;
823 fpregset_t *fp;
824 EOT
825 test_cxx "whether ucontext has FPU pointer" "yes" "no" ""
826 AC_DEFINE_UNQUOTED(CMK_CONTEXT_FPU_POINTER, $pass, [whether ucontext has pointer])
827
828 if test $pass -eq 1
829 then
830 cat > $t <<EOT
831 #include <ucontext.h>
832
833 int main()
834 {
835   ucontext_t context;
836   context.uc_mcontext.uc_regs = 0;
837 }
838 EOT
839 test_cxx "whether ucontext uses uc_regs" "yes" "no" ""
840 AC_DEFINE_UNQUOTED(CMK_CONTEXT_FPU_POINTER_UCREGS, $pass, [whether ucontext uses uc_regs union])
841 fi
842
843 cat > $t <<EOT
844 #include <ucontext.h>
845 vrregset_t *v_regs;
846 ucontext_t  uc;
847
848 void foo()
849 {
850   vrregset_t *ptr = uc.uc_mcontext.v_regs;
851 }
852 EOT
853 test_cxx "whether ucontext has pointer (v_regs) of vector type" "yes" "no" ""
854 AC_DEFINE_UNQUOTED(CMK_CONTEXT_V_REGS, $pass, [whether ucontext has pointer (v_regs) of vector type])
855
856 #### Check ucontext and FPU pointer ####
857 cat > $t <<EOT
858 #include <infiniband/verbs.h>
859 void test()
860 {
861     struct ibv_context    *context;
862     int ibPort;
863     struct ibv_port_attr attr;
864     if (ibv_query_port(context, ibPort, &attr) != 0) return;
865     if (attr.link_layer == IBV_LINK_LAYER_INFINIBAND)  return;
866 }
867 EOT
868 test_cxx "whether ibverbs ibv_port_attr has link_layer field" "yes" "no" ""
869 AC_DEFINE_UNQUOTED(CMK_IBV_PORT_ATTR_HAS_LINK_LAYER, $pass, [whether ibv_port_attr has link_layer field])
870
871
872 ###################### C++ Compiler Features #####################
873
874 #### check C inline ####
875 cat > $tc <<EOT
876 inline static int foo()
877 {
878   return 1;
879 }
880 EOT
881 test_cc "whether inline works in C" "yes" "no" ""
882 AC_DEFINE_UNQUOTED(CMK_C_INLINE, $strictpass, [whether C inline works in C])
883
884 #### check if signed char is same as char ####
885 cat > $t <<EOT
886 #include <stdlib.h>
887 class er {
888  protected:
889    void operator()(char &v,const char *desc=NULL) {};
890    void operator()(signed char &v,const char *desc=NULL) {};
891 };
892 EOT
893 test_cxx "whether C++ signed char and char differ" "yes" "no" ""
894 AC_DEFINE_UNQUOTED(CMK_SIGNEDCHAR_DIFF_CHAR, $pass, [whether C++ signed char and char differ])
895
896 ### check if varsize array on stack ####
897 cat > $t <<EOT
898 #include <stdio.h>
899 void foo()
900 {
901   int size=10;
902   char arr[size];
903 }
904
905 EOT
906 test_cxx "whether C++ allows declaration of varsize array" "yes" "no" ""
907 AC_DEFINE_UNQUOTED(CMK_DECLARE_VARSIZE_ARRAY, $pass, [whether C++ allows declaration of variable sized array])
908
909 #### check if typeinfo exists and works #####
910 cat > $t <<EOT
911 #include <typeinfo>
912 const char *foo(void) {
913         int x;
914         return typeid(x).name();
915 }
916 EOT
917 test_cxx "whether typeinfo/typeid works" "ok" "no" ""
918 AC_DEFINE_UNQUOTED(CMK_HAS_TYPEINFO, $pass, [whether typeinfo/typeid works])
919
920 #### check if iterator_traits is defined #####
921 cat > $t <<EOT
922 #include <iterator>
923
924 template <typename T> // T models Input Iterator
925 typename std::iterator_traits<T>::value_type accumulate(T first, T last)
926 {
927       typename std::iterator_traits<T>::value_type result = 0;
928       while(first != last)
929             result += *first++;
930       return result;
931 }
932 EOT
933 test_cxx "whether std::iterator_traits is defined" "ok" "no" ""
934 AC_DEFINE_UNQUOTED(CMK_HAS_ITERATOR_TRAITS, $pass, [whether iterator_traits works])
935
936 #### check if std::distance is defined #####
937 cat > $t <<EOT
938 #include <vector>
939 #include <iterator>
940
941 int foo()
942 {
943   std::vector<int> tree;
944   return std::distance(tree.begin(), tree.end());
945 }
946 EOT
947 test_cxx "whether std::distance is defined" "ok" "no" ""
948 AC_DEFINE_UNQUOTED(CMK_HAS_STD_DISTANCE, $pass, [whether std::distance works])
949
950 #### check if std::inserter is defined #####
951 cat > $t <<EOT
952 #include <list>
953 #include <iterator>
954
955 void foo()
956 {
957   using namespace std;
958   list<int> L;
959   inserter ( L, L.end ( ) ) = 500;
960 }
961 EOT
962 test_cxx "whether std::inserter is defined" "ok" "no" ""
963 AC_DEFINE_UNQUOTED(CMK_HAS_STD_INSERTER, $pass, [whether std::inserter works])
964
965
966 ####### Check support for features added by the new C11 and CPP11 standards ########
967
968 #### check if std::unordered_map is defined #####
969 cat > $t <<EOT
970 #include <unordered_map>
971
972 int foo()
973 {
974   std::unordered_map<int,int> myhashtbl;
975   myhashtbl[[0]] = 42;
976   myhashtbl[[1234]] = 0;
977   return myhashtbl[[1234]];
978 }
979 EOT
980 test_cxx "whether std::unordered_map is defined" "ok" "no" ""
981 AC_DEFINE_UNQUOTED(CMK_HAS_STD_UNORDERED_MAP, $pass, [whether std::unordered_map works])
982
983
984 #### check if anon structs are permitted #####
985 cat > $t <<EOT
986 #include <iostream>
987 using std::cout;
988
989 struct idx
990 {
991     const static int dims = 3;
992     union
993     {
994         int data[[dims]];
995         struct { int x, y, z; };
996     };
997
998     idx(const int i=0, const int j=0, const int k=0): x(i), y(j), z(k) {}
999 };
1000
1001 int main()
1002 {
1003     cout<<"Hello World!\n";
1004     idx myidx(1, 2, 3);
1005     cout<< "idx = ("
1006         << myidx.data[[0]] << ","
1007         << myidx.data[[1]] << ","
1008         << myidx.z << ")\n";
1009     return (myidx.data[[0]] == 1 && myidx.y == 2 && myidx.data[[2]] == 3);
1010 }
1011 EOT
1012 test_cxx "whether anon structs are permitted" "yes" "no" ""
1013 AC_DEFINE_UNQUOTED(CMK_HAS_ANON_STRUCTS, $pass, [whether anon structs are permitted])
1014
1015
1016 #### test if we can have multiple delete like this ####
1017 cat > $t <<EOT
1018 class foo {
1019 public:
1020   void operator delete(void*p){};
1021   void operator delete(void*p,int*){};
1022 };
1023 EOT
1024 test_cxx "whether operator delete can be overloaded in same class" "ok" "no" ""
1025 AC_DEFINE_UNQUOTED(CMK_MULTIPLE_DELETE, $strictpass, [whether operator delete can be overloaded in same class])
1026
1027 #### test if offsetof exists ####
1028 cat > $t <<EOT
1029 #include <stddef.h>
1030
1031 struct FooType {
1032         int f1;
1033         int f2;
1034         double f3;
1035 };
1036
1037 void foo()
1038 {
1039   int off = offsetof(FooType, f2);
1040 }
1041 EOT
1042 test_cxx "whether offsetof is defined" "yes" "no" ""
1043 AC_DEFINE_UNQUOTED(CMK_HAS_OFFSETOF, $pass, [whether offsetof exists])
1044
1045 #### test if we can use gcc x86 assembly like this ####
1046 cat > $t <<EOT
1047 double foo(void)
1048 {
1049   unsigned long long int v=0;
1050   int *lo=0+(int *)&v;
1051   int *hi=1+(int *)&v;
1052   __asm__ __volatile__(
1053       "rdtsc; movl %%edx,%0; movl %%eax,%1"
1054       : /* output  */ "=m" (*hi), "=m" (*lo)
1055       : /* input */
1056       : /* trashes */ "%edx", "%eax"
1057   );
1058   return v;
1059 }
1060 EOT
1061 test_cxx "whether GCC x86 assembly works" "yes" "no" ""
1062 AC_DEFINE_UNQUOTED(CMK_GCC_X86_ASM, $strictpass, [Allows gcc x86 assembly.])
1063
1064 #### test if we can use gcc x86 assembly like this ####
1065 if test $strictpass = 1
1066 then
1067 cat > $t <<EOT
1068 int foo(void)
1069 {
1070   int x;
1071   asm("lock incl %0" :: "m" (x));
1072   asm("lock decl %0" :: "m" (x));
1073   return x;
1074 }
1075 EOT
1076 test_cxx "whether GCC x86 assembly for atomic increment works" "yes" "no" ""
1077 AC_DEFINE_UNQUOTED(CMK_GCC_X86_ASM_ATOMICINCREMENT, $strictpass, [Allows gcc x86 assembly for atomic increment.])
1078 fi
1079
1080 #### test if we can use gcc IA64 assembly like this ####
1081 cat > $t <<EOT
1082 double foo(void)
1083 {
1084         unsigned long long int x;
1085         __asm__ __volatile__("mov %0=ar.itc" : "=r"(x) :: "memory");
1086         return x;
1087 }
1088 EOT
1089 test_cxx "whether GCC IA64 assembly works" "yes" "no" ""
1090 AC_DEFINE_UNQUOTED(CMK_GCC_IA64_ASM, $strictpass, [Allows gcc IA64 assembly.])
1091
1092
1093 #### test if we can use asm eieio assembly like this ####
1094 cat > $t <<EOT
1095 double foo(void)
1096 {
1097         unsigned long long int x;
1098         asm volatile("eieio" ::: "memory");
1099         return x;
1100 }
1101 EOT
1102 test_cxx "whether asm eieio assembly works" "yes" "no" ""
1103 AC_DEFINE_UNQUOTED(CMK_PPC_ASM, $strictpass, [Allows asm eieio assembly.])
1104
1105
1106
1107 #### test if we can use __thread ####
1108 cat > $t <<EOT
1109 __thread unsigned long long int x;
1110 static __thread  int y;
1111 void foo(void)
1112 {
1113         x = 1;
1114         y = 1;
1115 }
1116 EOT
1117 test_cxx "whether __thread (Thread Local Storage) is supported" "yes" "no" ""
1118 AC_DEFINE_UNQUOTED(CMK_HAS_TLS_VARIABLES, $strictpass, [Allows __thread.])
1119
1120 #### check __sync_add_and_fetch ####
1121 cat > $tc <<EOT
1122 #include <stdio.h>
1123 int main()
1124 {
1125   int t=1;
1126   __sync_add_and_fetch(&t, 1);
1127   return 1;
1128 }
1129 EOT
1130 test_linkc "whether synchronization primitives (__sync_add_and_fetch) works in C" "yes" "no" ""
1131 AC_DEFINE_UNQUOTED(CMK_C_SYNC_ADD_AND_FETCH_PRIMITIVE, $pass, [whether sync_add_and_fetch primitive works in C])
1132
1133 #### check __sync_synchronize ####
1134 cat > $tc <<EOT
1135 #include <stdio.h>
1136 int main()
1137 {
1138   __sync_synchronize();
1139 }
1140 EOT
1141
1142 test_linkc "whether synchronization primitives (__sync_synchronize) works in C" "yes" "no" ""
1143
1144 AC_DEFINE_UNQUOTED(CMK_C_SYNC_SYNCHRONIZE_PRIMITIVE, $pass, [whether sync_synchronize primitives works in C])
1145
1146
1147 #### check __BUILTIN_IA32_XFENCE ####
1148 cat > $tc <<EOT
1149 #include <stdio.h>
1150 #include <intrinsics.h>
1151 int main()
1152 {
1153   __builtin_ia32_lfence();  __builtin_ia32_sfence();   __builtin_ia32_mfence();
1154 }
1155 EOT
1156
1157 test_linkc "whether fence intrinsic primitives (__builtin_Xfence_ia32) works in C" "yes" "no" ""
1158
1159 AC_DEFINE_UNQUOTED(CMK_C_BUILTIN_IA32_XFENCE, $pass, [whether Xfence intrinsics works in C])
1160
1161
1162 ### test if switching TLS register ###
1163 if test $in64bit = 1
1164 then
1165 cat > $t <<EOT
1166 #include <elf.h>
1167 #include <stdlib.h>
1168 #include <malloc.h>
1169
1170 void switchTLS() {
1171   Elf64_Addr m1, m2;
1172   asm volatile ("movq %%fs:0x0, %0\n\t"
1173                 "movq %1, %%fs:0x0\n\t"
1174                 : "=r"(m1)
1175                 : "r"(m2));
1176 }
1177 EOT
1178 test_cxx "whether switching TLS register (64-bit) is supported" "yes" "no" ""
1179 AC_DEFINE_UNQUOTED(CMK_TLS_SWITCHING64, $strictpass, [Allows switching TLS 64-bit.])
1180 else
1181 cat > $t <<EOT
1182 #include <elf.h>
1183 #include <stdlib.h>
1184 #include <malloc.h>
1185
1186 void switchTLS() {
1187   Elf32_Addr m1, m2;
1188   asm volatile ("movl %%gs:0x0, %0\n\t"
1189                 "movl %1, %%gs:0x0\n\t"
1190                 : "=r"(m1)
1191                 : "r"(m2));
1192 }
1193 EOT
1194 test_cxx "whether switching TLS register (32-bit) is supported" "yes" "no" ""
1195 AC_DEFINE_UNQUOTED(CMK_TLS_SWITCHING32, $strictpass, [Allows switching TLS in 32-bit.])
1196 fi
1197
1198 #### test if we can build MPI ####
1199 if test "$CMK_BUILD_MPI" = 1
1200 then
1201
1202 cat > $t <<EOT
1203 #include "mpi.h"
1204 int main(int argc, char **argv)
1205 {
1206   MPI_Init(&argc, &argv);
1207 }
1208 EOT
1209 mv -f ../include/mpi.h ../include/mpi.h.bak 2>/dev/null
1210 test_cxx "whether build on MPI" "yes" "no" ""
1211 AC_DEFINE_UNQUOTED(CMK_BUILD_ON_MPI, $strictpass, [build MPI.])
1212 BUILD_MPI=$strictpass
1213
1214 if test $BUILD_MPI -eq 0
1215 then
1216   echo "Error: Can not compile a MPI program"
1217   test_finish 1
1218 fi
1219
1220 if test $BUILD_MPI -eq 1 -a -z "$BGP_FLOOR"
1221 then
1222   test_link "whether need to specify MPI library" "no" "yes" ""
1223   if test $pass -ne 1
1224   then
1225     if test -z "$CMK_MPI_LIB"
1226     then
1227       test_link "whether -lmpich" "ok" "no" "-lmpich"
1228       if test $pass -eq 1
1229       then
1230         add_flag CMK_SYSLIBS='"$CMK_SYSLIBS -lmpich"' "mpi lib"
1231       else
1232         test_link "whether -lmpi" "ok" "no" "-lmpi"
1233         if test $pass -eq 1
1234         then
1235                 add_flag CMK_SYSLIBS='"$CMK_SYSLIBS -lmpi"' "mpi lib"
1236         else
1237                 echo "Error: can not find mpi library"
1238                 test_finish 1
1239         fi
1240       fi
1241     else
1242       add_flag CMK_SYSLIBS='"$CMK_SYSLIBS $CMK_MPI_LIB"' "mpi lib"
1243     fi
1244   fi
1245 fi
1246
1247 if test "$BUILD_MPI" = "1"
1248 then
1249 cat > $t <<EOT
1250 #include "mpi.h"
1251 int main(int argc, char **argv)
1252 {
1253   int thread_level, provided;
1254   thread_level = MPI_THREAD_FUNNELED;
1255   MPI_Init_thread(&argc, &argv, thread_level, &provided);
1256 }
1257 EOT
1258 test_cxx "whether MPI_Init_thread is supported" "yes" "no" ""
1259 AC_DEFINE_UNQUOTED(CMK_MPI_INIT_THREAD, $strictpass, [Allows MPI_Init_thread.])
1260 fi
1261 mv -f ../include/mpi.h.bak ../include/mpi.h 2>/dev/null
1262
1263 fi
1264
1265 if test "$BUILD_MPI" = "1"
1266 then
1267
1268 cat > $t <<EOT
1269 #include <stdio.h>
1270 #include <mpi.h>
1271
1272 int main (int argc, char** argv) {
1273   return 0;
1274 }
1275 EOT
1276 test_cxx "whether macro conflicts occurs due to C++ MPI bindings" "no" "yes" ""
1277 AC_DEFINE_UNQUOTED(CMK_CXX_MPI_BINDINGS, $strictpass, [Disables conflicting macros.])
1278 fi
1279
1280
1281 ################### Syscalls and Libraries ###################
1282
1283 #### test for getrusage with RUSAGE_THREAD ###
1284 cat > $tc <<EOT
1285 #include <sys/time.h>
1286 #define __USE_GNU   1
1287 #include <sys/resource.h>
1288 int main() {
1289   struct rusage usage;
1290   getrusage(RUSAGE_THREAD, &usage);
1291   return 0;
1292 }
1293 EOT
1294 test_linkc "whether getrusage accepts RUSAGE_THREAD" "yes" "no" ""
1295 AC_DEFINE_UNQUOTED(CMK_HAS_RUSAGE_THREAD, $pass, [whether getrusage accepts RUSAGE_THREAD])
1296
1297 #### test for asctime ###
1298
1299 cat > $tc <<EOT
1300 #include <time.h>
1301 int main() {
1302   struct tm *local;
1303   time_t t;
1304   t = time(NULL);
1305   local = localtime(&t);
1306   asctime(local);
1307   return 0;
1308 }
1309 EOT
1310 test_linkc "whether has asctime" "yes" "no" ""
1311 AC_DEFINE_UNQUOTED(CMK_HAS_ASCTIME, $pass, [whether has asctime])
1312
1313 #### test for log2 ###
1314 cat > $t <<EOT
1315 #include <math.h>
1316 int main() {
1317   int i = log2(10);
1318   return 0;
1319 }
1320 EOT
1321 test_link "whether has log2" "yes" "no" ""
1322 AC_DEFINE_UNQUOTED(CMK_HAS_LOG2, $pass, [whether has log2])
1323
1324 #### test for sqrtf ###
1325 cat > $t <<EOT
1326 #include <math.h>
1327 int main() {
1328   float i = sqrtf((float)10.0);
1329   return 0;
1330 }
1331 EOT
1332 test_link "whether has sqrtf" "yes" "no" ""
1333 AC_DEFINE_UNQUOTED(CMK_HAS_SQRTF, $pass, [whether has sqrtf])
1334
1335 #### test for fabsf ###
1336 cat > $t <<EOT
1337 #include <math.h>
1338 int main() {
1339   float i = fabsf((float)10.0);
1340   return 0;
1341 }
1342 EOT
1343 test_link "whether has fabsf" "yes" "no" ""
1344 AC_DEFINE_UNQUOTED(CMK_HAS_FABSF, $pass, [whether has fabsf])
1345
1346 #### test for mkstemp ###
1347 cat > $t <<EOT
1348 #include <stdlib.h>
1349 #include <string.h>
1350 int main() {
1351   char fname[[128]];
1352   strcpy(fname, "/tmp/fdXXX.XXX");
1353   mkstemp(fname);
1354   return 0;
1355 }
1356 EOT
1357 test_link "whether has mkstemp" "yes" "no" ""
1358 AC_DEFINE_UNQUOTED(CMK_USE_MKSTEMP, $pass, [whether has mkstemp])
1359
1360 #### test for system ###
1361 cat > $t <<EOT
1362 #include <stdlib.h>
1363 int main() {
1364   system("/bin/ls");
1365   return 0;
1366 }
1367 EOT
1368 test_link "whether has system" "yes" "no" ""
1369 AC_DEFINE_UNQUOTED(CMK_HAS_SYSTEM, $pass, [whether has system])
1370
1371 #### test for sync() ###
1372 cat > $t <<EOT
1373 #include <unistd.h>
1374 int main() {
1375   sync();
1376   return 0;
1377 }
1378 EOT
1379 test_link "whether has sync()" "yes" "no" ""
1380 AC_DEFINE_UNQUOTED(CMK_HAS_SYNC_FUNC, $pass, [whether has sync])
1381
1382 #### test for fsync() ###
1383 cat > $t <<EOT
1384 #include <unistd.h>
1385 int main() {
1386   fsync(0);
1387   return 0;
1388 }
1389 EOT
1390 test_link "whether has fsync()" "yes" "no" ""
1391 AC_DEFINE_UNQUOTED(CMK_HAS_FSYNC_FUNC, $pass, [whether has fsync])
1392
1393 #### test for fdatasync() ###
1394 cat > $t <<EOT
1395 #include <unistd.h>
1396 int main() {
1397   fdatasync(0);
1398   return 0;
1399 }
1400 EOT
1401 test_link "whether has fdatasync()" "yes" "no" ""
1402 AC_DEFINE_UNQUOTED(CMK_HAS_FDATASYNC_FUNC, $pass, [whether has fdatasync])
1403
1404 #### test for sbrk ###
1405 cat > $t <<EOT
1406 #include <unistd.h>
1407 int main() {
1408   void *ptr  = sbrk(0); 
1409 }
1410 EOT
1411 test_link "whether has sbrk" "yes" "no" ""
1412 AC_DEFINE_UNQUOTED(CMK_HAS_SBRK, $pass, [whether has sbrk])
1413
1414 #### test for _setjmp/_longjmp ###
1415 cat > $t <<EOT
1416 #include <setjmp.h>
1417 int main() {
1418   jmp_buf buf;
1419   _setjmp(buf);
1420   _longjmp(buf, 0);
1421 }
1422 EOT
1423 test_link "whether has _setjmp/_longjmp" "yes" "no" ""
1424 AC_DEFINE_UNQUOTED(CMK_HAS_UNDERSCORE_SETJMP, $pass, [whether has _setjmp/_longjmp])
1425
1426 #### test for mstats ###
1427 cat > $t <<EOT
1428 #include <malloc.h>
1429 int main() {
1430   struct mstats ms = mstats();
1431 }
1432 EOT
1433 test_link "whether has mstats" "yes" "no" ""
1434 AC_DEFINE_UNQUOTED(CMK_HAS_MSTATS, $pass, [whether has mstats])
1435
1436 #### test for mallinfo ###
1437 cat > $t <<EOT
1438 #include <malloc.h>
1439 int main() {
1440   struct mallinfo mi = mallinfo();
1441 }
1442 EOT
1443 test_link "whether has mallinfo" "yes" "no" ""
1444 AC_DEFINE_UNQUOTED(CMK_HAS_MALLINFO, $pass, [whether has mallinfo])
1445
1446 #### test for popen ###
1447 cat > $t <<EOT
1448 #include <stdio.h>
1449 int main() {
1450   FILE *p = popen("/bin/ps", "r");
1451   pclose(p);
1452 }
1453 EOT
1454 test_link "whether has popen" "yes" "no" ""
1455 AC_DEFINE_UNQUOTED(CMK_HAS_POPEN, $pass, [whether has popen])
1456
1457 #### test for poll ###
1458 cat > $t <<EOT
1459 #include <poll.h>
1460 void foo(void) { 
1461   struct pollfd pos[[3]];
1462   poll(pos, 1, 1);
1463 }
1464 EOT
1465 test_cxx "whether has poll" "yes" "no" ""
1466 AC_DEFINE_UNQUOTED(CMK_USE_POLL, $pass, [whether the poll syscall exists])
1467
1468 #### check if getpagesize exists ####
1469 cat > $tc <<EOT
1470 #include <unistd.h>
1471
1472 int main(int argc, char **argv) {
1473     int s = getpagesize();
1474 }
1475 EOT
1476 test_linkc "whether has getpagesize" "yes" "no" ""
1477 AC_DEFINE_UNQUOTED(CMK_HAS_GETPAGESIZE, $pass, [whether getpagesize exists])
1478
1479 #### check if getpid exists ####
1480 cat > $tc <<EOT
1481 #include <sys/types.h>
1482 #include <unistd.h>
1483
1484 int main(int argc, char **argv) {
1485     pid_t pid = getpid();
1486 }
1487 EOT
1488 test_linkc "whether has getpid" "yes" "no" ""
1489 AC_DEFINE_UNQUOTED(CMK_HAS_GETPID, $pass, [whether getpid exists])
1490
1491 #### check if kill exists ####
1492 cat > $tc <<EOT
1493 #include <sys/types.h>
1494 #include <unistd.h>
1495 #include <signal.h>
1496
1497 int main(int argc, char**argv) 
1498 {
1499     pid_t pid = getpid();
1500     kill(pid, 9);
1501 }
1502 EOT
1503 test_linkc "whether has kill" "yes" "no" ""
1504 AC_DEFINE_UNQUOTED(CMK_HAS_KILL, $pass, [whether kill exists])
1505
1506 #### test for setpriority ###
1507 cat > $t <<EOT
1508 #include <sys/time.h>
1509 #include <sys/resource.h>
1510 void foo(void) { 
1511   setpriority(PRIO_PROCESS, 0, 0);
1512 }
1513 EOT
1514 test_cxx "whether has setpriority" "yes" "no" ""
1515 AC_DEFINE_UNQUOTED(CMK_HAS_SETPRIORITY, $pass, [whether the setpriority exists])
1516
1517 #### test for system ###
1518 cat > $t <<EOT
1519 #include "ckdll_system.C"
1520 EOT
1521 test_cxx "whether to use signal-safe system() " "yes" "no" ""
1522 AC_DEFINE_UNQUOTED(CMK_SIGSAFE_SYSTEM, $pass, [whether to use signal-safe system()])
1523
1524 ### test sched_setaffinity ####
1525 cat > $tc <<EOT
1526 #define _GNU_SOURCE
1527 #include <sched.h>
1528
1529 int main()
1530 {
1531   cpu_set_t cpuset;
1532   CPU_ZERO(&cpuset);
1533   CPU_SET(0, &cpuset);
1534   if (sched_setaffinity(0, sizeof(cpuset), &cpuset) < 0) {
1535     return -1;
1536   }
1537   return 0;
1538 }
1539 EOT
1540 test_linkc "whether sched_setaffinity call exists" "yes" "no" ""
1541 AC_DEFINE_UNQUOTED(CMK_HAS_SETAFFINITY, $pass, [whether the sched_setaffinity() exists])
1542
1543 ### test pthread_setaffinity_np ####
1544 cat > $tc <<EOT
1545 #include <stdlib.h>
1546 #include <stdio.h>
1547 #include <unistd.h>
1548 #include <pthread.h>
1549
1550 int main()
1551 {
1552   unsigned long mask = 0xffffffff;
1553   unsigned int len = sizeof(mask);
1554
1555   if (pthread_setaffinity_np(pthread_self(), len, &mask) < 0) {
1556     return -1;
1557   }
1558   return 0;
1559 }
1560 EOT
1561 test_linkc "whether pthread_setaffinity_np call exists" "yes" "no" "-lpthread"
1562 AC_DEFINE_UNQUOTED(CMK_HAS_PTHREAD_SETAFFINITY, $pass, [whether the pthread_setaffinity_np() exists])
1563
1564 ### test pthread_spin_lock ####
1565 cat > $tc <<EOT
1566 #include <stdlib.h>
1567 #include <stdio.h>
1568 #include <unistd.h>
1569 #include <pthread.h>
1570
1571 int main()
1572 {
1573   pthread_spinlock_t  lock;
1574
1575   pthread_spin_init(&lock, 0);
1576
1577   pthread_spin_lock(&lock);
1578
1579   return 0;
1580 }
1581 EOT
1582 test_linkc "whether pthread_spin_lock exists" "yes" "no" "-lpthread"
1583 AC_DEFINE_UNQUOTED(CMK_HAS_SPINLOCK, $pass, [whether the pthread_spin_lock exists])
1584
1585 ### check libnuma on Linux ####
1586 if test "$WITH_NUMA" = "yes"
1587 then
1588 cat > $tc <<EOT
1589 #include <stdlib.h>
1590 #include <stdio.h>
1591 #include <linux/mempolicy.h>
1592 #include <numaif.h>
1593 #include <numa.h>
1594
1595 int main()
1596 {
1597   if (get_mempolicy(NULL, NULL, 0, 0, 0) == 0) return 0;
1598   return -1;
1599 }
1600 EOT
1601 test_linkc "whether libnuma exists" "yes" "no" "-lnuma"
1602 AC_DEFINE_UNQUOTED(CMK_HAS_NUMACTRL, $pass, [whether NUMA control related functions exist])
1603 if test $pass -eq 1
1604 then
1605         add_flag 'CMK_SYSLIBS="$CMK_SYSLIBS -lnuma"' "libnuma"
1606 fi
1607 fi
1608
1609 #### check bindprocessors on AIX ####
1610 cat > $tc <<EOT
1611 #include <stdlib.h>
1612 #include <stdio.h>
1613 #include <unistd.h>
1614
1615 #include <sys/processor.h>
1616
1617 int main()
1618 {
1619   int retValue = 0;
1620   int pid;
1621   pid = getpid();
1622   if (bindprocessor(BINDPROCESS, pid, 0) == -1) return -1;
1623   return 0;
1624 }
1625 EOT
1626 test_linkc "whether bindprocessor call exists" "yes" "no" ""
1627 AC_DEFINE_UNQUOTED(CMK_HAS_BINDPROCESSOR, $pass, [whether the bindprocessor()
1628 exists])
1629
1630
1631 #### check if dlopen works ####
1632 skip_dl=0
1633 # for bproc, ignore -ldl
1634 test -n "$CMK_BPROC" && skip_dl=1
1635 test -n "$CMK_NO_DL" && skip_dl=1
1636 dl_opt='-ldl'
1637 #workaround for pgcc 4.0, -ldl crash linking, so use -Wl,-ldl to skip the prelinker.
1638 case "$CMK_CXX" in
1639 pgCC*) dl_opt='-Wl,-ldl' ;;
1640 esac
1641
1642 if test $skip_dl -eq 0 
1643 then
1644
1645 cat > $t <<EOT
1646 #include "ckdll_dlopen.C"
1647 int main() {
1648         CkDll dll("foo.so");
1649         return 0;
1650 }
1651 EOT
1652 test_link "whether dlopen links without $dl_opt" "yes" "no" ""
1653 noldl=$pass
1654 test_link "whether dlopen links with $dl_opt" "yes" "no" "$dl_opt"
1655 if test $pass -eq 1
1656 then 
1657 #dlopen requires -ldl: add it to our link line
1658         add_flag CMK_LIBS='"$CMK_LIBS '$dl_opt'"' "dlopen"
1659 fi
1660
1661 if test $pass -eq 1 -o $noldl -eq 1
1662 then
1663 # One version or another of dlopen worked: compile it in
1664         AC_DEFINE_UNQUOTED(CMK_DLL_USE_DLOPEN, 1, [dlopen])
1665 fi
1666
1667 ### test gethostname ####
1668 cat > $tc <<EOT
1669 #ifdef WIN32
1670 #include <Winsock2.h>
1671 #else
1672 #include <stdlib.h>
1673 #include <stdio.h>
1674 #include <unistd.h>
1675 #endif
1676
1677 int main()
1678 {
1679   char hostname[[1000]];
1680   gethostname(hostname, 999);
1681   return 0;
1682 }
1683 EOT
1684 test_linkc "whether gethostname call exists" "yes" "no" ""
1685 AC_DEFINE_UNQUOTED(CMK_HAS_GETHOSTNAME, $pass, [whether gethostname() exists])
1686
1687 #### check if getProcAddress works ####
1688 cat > $t <<EOT
1689 #include "ckdll_win32.C"
1690 EOT
1691 test_cxx "whether getProcAddress works" "yes" "no" ""
1692 AC_DEFINE_UNQUOTED(CMK_DLL_USE_WIN32, $pass, [whether getProcAddress works])
1693
1694 fi    # end of skip_dl
1695
1696 #### check if socklen_t exists ####
1697 cat > $t <<EOT
1698 #include <sys/types.h>
1699 #include <sys/socket.h>
1700
1701 void foo(void) {
1702         int i;
1703         socklen_t s=sizeof(i);
1704 }
1705 EOT
1706 test_cxx "whether has socklen_t" "yes" "no" ""
1707 AC_DEFINE_UNQUOTED(CMK_HAS_SOCKLEN, $pass, [whether has socklen_t])
1708
1709 ### test getifaddrs ####
1710 cat > $tc <<EOT
1711 #include <netinet/in.h> /* for sockaddr_in */
1712 #include <ifaddrs.h> /* for getifaddrs */
1713 #include <net/if.h> /* for IFF_RUNNING */
1714
1715 int main()
1716 {
1717   struct ifaddrs *interfaces=0;
1718   if( getifaddrs(&interfaces) == 0 ) {
1719         struct ifaddrs *interface;
1720         for( interface=interfaces; interface; interface=interface->ifa_next ) {
1721             if( (interface->ifa_flags & IFF_UP) && ! (interface->ifa_flags & IFF_LOOPBACK) ) {
1722                 const struct sockaddr_in *addr = (const struct sockaddr_in*)interface->ifa_addr;
1723                 if( addr && addr->sin_family==AF_INET ) {
1724                     break;
1725                 }
1726             }
1727         }
1728         freeifaddrs(interfaces);
1729   }
1730 }
1731 EOT
1732 test_linkc "whether getifaddrs call exists" "yes" "no" ""
1733 AC_DEFINE_UNQUOTED(CMK_HAS_GETIFADDRS, $pass, [whether getifaddrs() exists])
1734
1735 #### check if mmap exists ####
1736 cat > $t <<EOT
1737 #include <sys/types.h>
1738 #include <sys/mman.h>
1739
1740 void *foo(void *a,int l,int fd) {
1741         return mmap((caddr_t)a,l,PROT_READ+PROT_WRITE,
1742                  MAP_FIXED+MAP_PRIVATE,fd,0);
1743 }
1744 EOT
1745 test_cxx "whether the mmap() syscall exists" "yes" "no" ""
1746 AC_DEFINE_UNQUOTED(CMK_HAS_MMAP, $pass, [whether the mmap() syscall exists])
1747
1748 #### check if mmap accepts MAP_ANON ####
1749 cat > $t <<EOT
1750 #include <sys/types.h>
1751 #include <sys/mman.h>
1752
1753 void *foo(void *a,int l) {
1754         return mmap((caddr_t)a,l,PROT_READ+PROT_WRITE,
1755                 MAP_FIXED+MAP_PRIVATE+MAP_ANON,-1,0);
1756 }
1757 EOT
1758 test_cxx "whether mmap() accepts MAP_ANON" "yes" "no" ""
1759 AC_DEFINE_UNQUOTED(CMK_HAS_MMAP_ANON, $pass, [whether mmap() accepts MAP_ANON])
1760
1761 #### check if mmap accepts MAP_NORESERVE ####
1762 cat > $t <<EOT
1763 #include <sys/types.h>
1764 #include <sys/mman.h>
1765
1766 void *foo(void *a,int l) {
1767         return mmap((caddr_t)a,l,PROT_READ+PROT_WRITE,
1768                 MAP_FIXED+MAP_PRIVATE+MAP_NORESERVE,-1,0);
1769 }
1770 EOT
1771 test_cxx "whether mmap() accepts MAP_NORESERVE" "yes" "no" ""
1772 AC_DEFINE_UNQUOTED(CMK_HAS_MMAP_NORESERVE, $pass, [whether mmap() accepts MAP_NORESERVE])
1773
1774 #### check if get_myaddress exists ####
1775 cat > $t <<EOT
1776 #include <rpc/rpc.h>
1777
1778 void foo(void *a) {
1779     get_myaddress((struct sockaddr_in*)a);
1780 }
1781 EOT
1782 test_cxx "whether has get_myaddress" "yes" "no" ""
1783 AC_DEFINE_UNQUOTED(CMK_HAS_GET_MYADDRESS, $pass, [whether has get_myaddress])
1784
1785 #### check if mprotect exists ####
1786 cat > $t <<EOT
1787 #include <stdio.h>
1788 #include <sys/mman.h>
1789
1790 void foo(void *a,int l,int fd) {
1791      void *pg = NULL;
1792      size_t pagesize = 4096;
1793      mprotect(pg, pagesize, PROT_READ | PROT_WRITE);
1794 }
1795 EOT
1796 test_cxx "whether has mprotect" "yes" "no" ""
1797 AC_DEFINE_UNQUOTED(CMK_HAS_MPROTECT, $pass, [whether has mprotect])
1798
1799 #### check if glibc backtrace exists ####
1800 cat > $t <<EOT
1801 #include "cmibacktrace.c"
1802
1803 int main() {
1804         int nLevels=1;
1805         void *stack;
1806         CmiBacktraceRecord(&stack,0,&nLevels);
1807         return 0;
1808 }
1809 EOT
1810 TRACE_LINK_FLAG="-rdynamic"
1811 test_link "whether glibc backtrace works" "yes" "no" "-DCMK_USE_BACKTRACE=1 $TRACE_LINK_FLAG"
1812 AC_DEFINE_UNQUOTED(CMK_USE_BACKTRACE, $pass, [whether glibc backtrace works])
1813
1814 if test $strictpass -eq 1
1815 then 
1816         add_flag 'CMK_LD="$CMK_LD '$TRACE_LINK_FLAG'"' "backtrace"
1817         add_flag 'CMK_LDXX="$CMK_LDXX '$TRACE_LINK_FLAG'"' "backtrace"
1818 fi
1819
1820 #### test sleep ####
1821 cat > $t <<EOT
1822 #include <unistd.h>
1823 int main() {
1824   sleep(1);
1825   return 0;
1826 }
1827 EOT
1828 test_cxx "whether has sleep " "yes" "no" ""
1829 AC_DEFINE_UNQUOTED(CMK_HAS_SLEEP, $pass, [whether has sleep])
1830
1831 #### test usleep ####
1832 cat > $t <<EOT
1833 #include <unistd.h>
1834 int main() {
1835   usleep(100);
1836   return 0;
1837 }
1838 EOT
1839 test_cxx "whether has usleep " "yes" "no" ""
1840 AC_DEFINE_UNQUOTED(CMK_HAS_USLEEP, $pass, [whether has usleep])
1841
1842 #### test personality() and ADDR_NO_RANDOMIZE ####
1843 # Only works on modern Linux systems
1844 cat > $t <<EOT
1845 #include <sys/personality.h>
1846 int main() {
1847     int orig_persona = personality(0xffffffff);
1848     personality(orig_persona | ADDR_NO_RANDOMIZE);
1849     return 0;
1850 }
1851 EOT
1852 test_cxx "whether personality() and ADDR_NO_RANDOMIZE exist" "yes" "no" ""
1853 AC_DEFINE_UNQUOTED(CMK_HAS_ADDR_NO_RANDOMIZE, $pass, [whether personality() and ADDR_NO_RANDOMIZE exist])
1854
1855
1856 #### test if has zlib ####
1857 # bproc doesnot like -lz in any case
1858 if test -z "$CMK_BPROC"
1859 then
1860
1861 cat > $t <<EOT
1862 #include <zlib.h>
1863 int main() { 
1864   gzFile f = gzopen("/tmp/x","r");
1865   gzprintf(f, "test...\n");
1866   gzclose(f);
1867   return 0;
1868 }
1869 EOT
1870 test_link "whether has zlib" "yes" "no" "-lz"
1871 AC_DEFINE_UNQUOTED(CMK_PROJECTIONS_USE_ZLIB, $pass, [whether has zlib])
1872 if test $pass -eq 1
1873 then 
1874         add_flag 'CMK_LIBZ="-lz"' "zlib"
1875 fi
1876
1877 fi
1878
1879 #### test if has elf.h ####
1880 cat > $t <<EOT
1881 #include <elf.h>
1882 typedef Elf32_Addr ELF_TYPE_Addr;
1883 int main() { 
1884 }
1885 EOT
1886 test_cxx "whether has elf.h " "yes" "no" ""
1887 AC_DEFINE_UNQUOTED([CMK_HAS_ELF_H], $pass, [whether has elf.h])
1888
1889 #### test if has Multiprocessing.h for apple ####
1890 cat > $t <<EOT
1891 #include <Carbon/Carbon.h>
1892 #include <Multiprocessing.h>
1893 int main() {
1894   int a = MPProcessorsScheduled();
1895 }
1896 EOT
1897 test_cxx "whether has Multiprocessing.h for Apple " "yes" "no" ""
1898 AC_DEFINE_UNQUOTED([CMK_HAS_MULTIPROCESSING_H], $pass, [whether has Multiprocessing.h])
1899
1900 #### test if "ntohl" is available ####
1901 cat > $t <<EOT
1902 #if defined(_WIN32) && ! defined(__CYGWIN__) || defined(__MINGW_H)
1903 #include <winsock.h>
1904 #else
1905 #include <stdint.h>
1906 #include <arpa/inet.h>
1907 #include <netinet/in.h>
1908 #endif
1909
1910 int main() {
1911   int i = 100;
1912   i = ntohl(i);
1913   return 0;
1914 }
1915 EOT
1916 test_link "whether ntohl is available" "yes" "no" ""
1917 AC_DEFINE_UNQUOTED(CMK_HAS_NTOHL, $pass, [whether ntohl is available])
1918
1919 ### test for libjpeg ####
1920 cat > $t <<EOT
1921 #include <stdio.h>
1922 #include <stdlib.h>
1923 #include "jpeglib.h"
1924
1925 int main()
1926 {
1927   struct jpeg_compress_struct cinfo;
1928   jpeg_create_compress(&cinfo);
1929   return 0;
1930 }
1931 EOT
1932 test_link "whether has libjpeg" "yes" "no" "-ljpeg"
1933 AC_DEFINE_UNQUOTED(CMK_USE_LIBJPEG, $pass, [whether has libjpeg])
1934 if test $pass -eq 1
1935 then
1936         add_flag 'CMK_LIBJPEG="-ljpeg"' "libjpeg"
1937 fi
1938
1939 #### check if PAPI exists ####
1940 if test -n "$CMK_USE_PAPI"
1941 then
1942 cat > $t <<EOT
1943 #include <stdio.h>
1944 #include <papi.h>
1945                                                                                 
1946 int main() {
1947     if (PAPI_library_init(PAPI_VER_CURRENT) != PAPI_VER_CURRENT) return 1;
1948     return 0;
1949 }
1950 EOT
1951 test_link "whether PAPI exists" "yes" "no" "-lpapi"
1952 AC_DEFINE_UNQUOTED(CMK_HAS_COUNTER_PAPI, $pass, [whether PAPI exists])
1953 if test $pass -eq 1
1954 then 
1955         add_flag 'CMK_LIBS="$CMK_LIBS -lpapi"' "papi"
1956 fi
1957 fi
1958
1959 #### test if Python headers are installed ####
1960 PYTHON_VERSION=`python -V 2>&1 | awk {'print $2'} | awk -F. {'print $1"."$2'}`
1961 cat > $t <<EOT
1962 #include "python${PYTHON_VERSION}/Python.h"
1963 #include "python${PYTHON_VERSION}/compile.h"
1964 #include "python${PYTHON_VERSION}/eval.h"
1965 #include "python${PYTHON_VERSION}/node.h"
1966
1967 int main() {
1968     Py_Initialize();
1969     PyEval_InitThreads();
1970     struct _node* programNode = PyParser_SimpleParseString("return 1\n",Py_file_input);
1971     PyCodeObject *program = PyNode_Compile(programNode, "");
1972 }
1973 EOT
1974 test_link "whether Python is installed" "yes" "no" "-lpython$PYTHON_VERSION -lpthread -lutil -ldl"
1975 AC_DEFINE_UNQUOTED(CMK_HAS_PYTHON, $pass, [whether Python is installed])
1976 AC_DEFINE_UNQUOTED(CMK_PYTHON_VERSION, ${PYTHON_VERSION}, [Python version])
1977 if test $pass -eq 1
1978 then
1979         add_flag "CMK_BUILD_PYTHON=$PYTHON_VERSION" "python"
1980 fi
1981
1982 #### Pick up METIS if the user asks for it ####
1983
1984 AC_ARG_WITH([metis],
1985             [AS_HELP_STRING([--with-metis],
1986              [support the METIS graph partitioner and associated load balancer])],
1987             [],
1988             [with_metis=no])
1989
1990 WITH_METIS=no
1991 if test "$with_metis" != "no"
1992 then
1993   Echo "Compiling Charm with support for METIS"
1994   WITH_METIS=yes
1995   echo 'charm++: $(L)/libmoduleMetisLB.a $(L)/libmoduleTeamLB.a' >> $MAKEFILE_EXT
1996   add_flag 'CMK_LIBS="$CMK_LIBS -lmetis"' "libmetis"
1997   if test "$with_metis" != "yes"
1998   then
1999     add_flag "CMK_METIS=$with_metis" "Where to find METIS"
2000     add_flag 'CMK_LIBDIR="$CMK_LIBDIR -L$CMK_METIS"' "Library path for METIS"
2001     if test -r $with_metis/Lib/metis.h
2002     then
2003       add_flag 'CMK_INCDIR="$CMK_INCDIR -I$CMK_METIS/Lib"' "Include path for METIS 4"
2004     elif test -r $with_metis/../include/metis.h
2005     then
2006       add_flag 'CMK_INCDIR="$CMK_INCDIR -I$CMK_METIS/../include"' "Include path for METIS 5"
2007     else
2008       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."
2009       test_finish 1
2010     fi
2011   fi
2012 fi
2013
2014 ## Cray specific test
2015 if test "$CMK_BUILD_CRAY" = "1"
2016 then
2017 #echo "Test for known incompatible compiler versions"
2018
2019  if test "$CRAY_CC_VERSION" = "8.1.4"
2020  then
2021         echo "CCE 8.1.4 produces incorrect Charm++ code"
2022         echo "Please use a newer version of the CCE compiler"
2023         echo "e.g. module load cce/8.1.7"
2024         test_finish 1
2025  fi
2026
2027 #### test if Cray node topology will work ####
2028 cat > $tc <<EOT
2029 #include <pmi.h>
2030
2031 int main() {
2032     int nid;
2033     PMI_Get_nid(0, &nid);
2034
2035     return 0;
2036 }
2037 EOT
2038 test_linkc "whether PMI_Get_nid exists" "yes" "no" ""
2039 AC_DEFINE_UNQUOTED(CMK_HAS_PMI_GET_NID, $pass, [whether PMI_Get_nid exists])
2040
2041 #### test if Cray mesh topology will work ####
2042 cat > $tc <<EOT
2043 #include <rca_lib.h>
2044
2045 int main() {
2046     rca_mesh_coord_t xyz;
2047     rca_get_meshcoord(0, &xyz);
2048
2049     return 0;
2050 }
2051 EOT
2052 test_linkc "whether Cray rca library is available" "yes" "no" "$CRAY_RCA_POST_LINK_OPTS -lrca"
2053 AC_DEFINE_UNQUOTED(CMK_HAS_RCALIB, $pass, [whether Cray rca library is available])
2054
2055 #### test if Cray mesh dimension query function will work ####
2056 cat > $tc <<EOT
2057 #include <rca_lib.h>
2058
2059 int main() {
2060     rca_mesh_coord_t xyz;
2061     rca_get_max_dimension(&xyz);
2062
2063     return 0;
2064 }
2065 EOT
2066 test_linkc "whether Cray rca_has get_max_dimension" "yes" "no" "$CRAY_RCA_POST_LINK_OPTS -lrca"
2067 AC_DEFINE_UNQUOTED(CMK_HAS_RCA_MAX_DIMENSION, $pass, [whether Cray rca has rca_get_max_dimension])
2068
2069 #### query Cray machine max NID if get_max_dimension not exist ####
2070
2071 if test $pass -eq 0
2072 then
2073 cmd=`which xtprocadmin 2>/dev/null`
2074 if test -n "$cmd"
2075 then
2076     #maxnid=`xtprocadmin  | tail -1  | awk '{print $1}'`
2077     # workaround for hopper
2078     (export SHELL=/bin/csh; xtprocadmin >& t.$$)
2079     maxnid=`cat t.$$  | tail -1  | awk '{print $1}'`
2080     /bin/rm -f t.$$
2081     AC_MSG_CHECKING(Cray machine maxnid)
2082     AC_MSG_RESULT("$maxnid")
2083     if test -n "$maxnid"
2084     then
2085     AC_DEFINE_UNQUOTED(CMK_CRAY_MAXNID, $maxnid, [Cray MAXNID])
2086     fi
2087 fi
2088 fi
2089
2090
2091
2092
2093 #### query Cray machine supports BANDWIDTH_INJECTION controls####
2094
2095 if test "$CMK_BUILD_MPI" = "1"
2096 then
2097 echo "BALANCED_INJECTION test disabled on MPI"
2098 elif test "$GNI_CRAYXC" = "1"
2099 then
2100 echo "BALANCED_INJECTION test disabled on Aries network"
2101 else
2102 cat > $tc <<EOT
2103 #include <stdint.h>
2104 #include <gni_pub.h>
2105
2106 int main() {
2107     gni_bi_desc_t gni_bi_desc;
2108     uint32_t gni_device_id = 0;
2109     gni_return_t gni_rc = GNI_GetBIConfig(gni_device_id, &gni_bi_desc);
2110     if (gni_rc == GNI_RC_SUCCESS) {
2111     }
2112     return 0;
2113 }
2114 EOT
2115 test_linkc "whether GNI_GetBIConfig exists" "yes" "no" ""
2116 AC_DEFINE_UNQUOTED(CMK_BALANCED_INJECTION_API, $pass, [whether Cray gni_pub has GNI_GetBIConfig])
2117 fi # end of BIConfig test
2118
2119
2120 fi  # end of Cray specific test
2121
2122 #### test if it can build shared library ####
2123 cat > $t <<EOT
2124 #include "stdlib.h"
2125 extern int foo();
2126 int foo1() { 
2127   void * t= malloc(2);
2128   foo();
2129   return 0;
2130 }
2131 EOT
2132 test_linkso "whether can build shared library" "yes" "no" ""
2133 if test $pass -eq 0
2134 then 
2135         add_flag 'CMK_NO_BUILD_SHARED="true"' "build-shared"
2136 else
2137         BUILD_SHARED=1
2138         if test "$BUILD_MPI" = "1"
2139         then
2140 cat > $t <<EOT
2141 #include "stdlib.h"
2142 #include "mpi.h"
2143 extern int foo();
2144 int foo(int argc, char ** argv) {
2145   void * t= malloc(2);
2146   foo();
2147   MPI_Init(&argc, &argv);
2148   return 0;
2149 }
2150 EOT
2151                 test_linkso "whether can build shared library with MPI" "yes" "no" ""
2152                 BUILD_SHARED=$pass
2153         fi
2154         if test $BUILD_SHARED -eq 0
2155         then
2156                 add_flag 'CMK_NO_BUILD_SHARED="true"' "build-shared"
2157         fi
2158 fi
2159
2160 #### test the version number of bproc ####
2161 if test -n "$CMK_BPROC"
2162 then
2163 cat > $t <<EOT
2164 #include <stdio.h>
2165 #include <sys/bproc.h>
2166 int main()
2167 {
2168   struct bproc_version_t vers;
2169   bproc_version(&vers);
2170   printf("%s\n", vers.version_string);
2171 }
2172 EOT
2173 test_link "whether bproc compiles" "yes" "no" "-lbproc"
2174 if test $pass -eq 1
2175 then 
2176 AC_MSG_CHECKING("bproc version")
2177 bproc_ver=`./testlink`
2178 if test x$bproc_ver = x
2179 then
2180 test_result 0 "bproc version" "ERROR" ""
2181 test_finish 1
2182 else
2183 test_result 0 "bproc version" "$bproc_ver" ""
2184 fi
2185 bproc_ver=`echo $bproc_ver | cut -d'.' -f1`
2186 AC_DEFINE_UNQUOTED(CMK_BPROC_VERSION, $bproc_ver, [bproc version])
2187 fi
2188 fi
2189
2190 #### test the if command sync exists ####
2191 AC_CHECK_PROG(SYNC, sync, sync )
2192 if test -n "$SYNC"
2193 then
2194 AC_DEFINE_UNQUOTED(CMK_HAS_SYNC, 1, [sync program])
2195 fi
2196
2197 ################## Fortran #########################
2198
2199 #echo "set F77 compiler as: $CMK_CF77"
2200 AC_MSG_CHECKING("F77 compiler as")
2201 AC_MSG_RESULT("$CMK_CF77")
2202
2203 AC_MSG_CHECKING("whether Fortran 77 compiler works")
2204 ### test fortran 77 compiler ###
2205 cat > conftest.f <<EOF
2206       SUBROUTINE FOO_foo
2207       END
2208 EOF
2209 $CMK_CF77 -c conftest.f > /dev/null 2> /dev/null
2210 if test ! -r conftest.o
2211 then
2212   AC_MSG_RESULT("no")
2213 else
2214   AC_MSG_RESULT("yes")
2215 fi
2216
2217 ### test fortran 90 compiler ###
2218 #echo "set F90 compiler as: $CMK_CF90"
2219 AC_MSG_CHECKING("F90 compiler as")
2220 AC_MSG_RESULT("$CMK_CF90")
2221
2222 AC_MSG_CHECKING("whether Fortran 90 compiler works")
2223 cat > conftest2.f90 <<EOF
2224       SUBROUTINE FOO_foo
2225       END
2226 EOF
2227 $CMK_CF90 -c conftest2.f90 > /dev/null 2> /dev/null
2228 if test ! -r conftest2.o
2229 then
2230   AC_MSG_RESULT("no")
2231 else
2232   AC_MSG_RESULT("yes")
2233   mv -f conftest2.o conftest.o
2234   USE_FORTRAN90=1
2235 fi
2236
2237 ### check fortran name mangling
2238 AC_MSG_CHECKING(subroutine name used by Fortran 90 compiler)
2239
2240 if test -r conftest.o
2241 then
2242   AC_CACHE_VAL(_cv_fortran_postfix,
2243
2244   NAME=`$CMK_NM conftest.o | grep "foo_foo__"`
2245   if test "$NAME" != ""
2246   then
2247     _cv_fortran_postfix=TWOSCORE
2248     AC_DEFINE_UNQUOTED(CMK_FORTRAN_USES_TWOSCORE, 1, [TWOSCORE])
2249   else
2250     NAME=`$CMK_NM conftest.o | grep "foo_foo_"`
2251     if test "$NAME" != ""
2252     then
2253       _cv_fortran_postfix=ONESCORE
2254       AC_DEFINE_UNQUOTED(CMK_FORTRAN_USES_ONESCORE, 1, [ONESCORE])
2255     else
2256       NAME=`$CMK_NM conftest.o | grep "foo_foo"`
2257       if test "$NAME" != ""
2258       then
2259         _cv_fortran_postfix=NOSCORE
2260         AC_DEFINE_UNQUOTED(CMK_FORTRAN_USES_NOSCORE, 1, [NOSCORE])
2261       else
2262         NAME=`$CMK_NM conftest.o | grep "FOO_FOO"`
2263         if test "$NAME" != ""
2264         then
2265           _cv_fortran_postfix=ALLCAPS
2266           AC_DEFINE_UNQUOTED(CMK_FORTRAN_USES_ALLCAPS, 1, [ALLCAPS])
2267         else
2268           echo "#################################################"
2269           echo "FORTRAN compiler generated name not supported yet"
2270           echo "#################################################"
2271         fi
2272       fi
2273     fi
2274   fi
2275   rm -f conftest.f conftest.o
2276   )
2277   AC_MSG_RESULT($_cv_fortran_postfix)
2278 else
2279   AC_MSG_RESULT("Fortran compiler not working")
2280 fi
2281
2282 ### check module name ###
2283
2284 if test "$USE_FORTRAN90" = 1
2285 then
2286   cat > conftest.f90 <<EOF
2287       MODULE testmod
2288         interface 
2289           function fpup_issizing(p)
2290           INTEGER :: p
2291           logical fpup_issizing
2292           end function
2293         end interface
2294       END MODULE
2295 EOF
2296   AC_MSG_CHECKING(Fortran 90 mod name is capital)
2297   $CMK_CF90 -c conftest.f90 > /dev/null 2> /dev/null
2298   name=`ls TESTMOD.* 2>/dev/null`
2299   if test -n "$name"
2300   then
2301         AC_MSG_RESULT("yes")
2302         add_flag 'CMK_MOD_NAME_ALLCAPS=1' "mod name capital"
2303   else
2304         AC_MSG_RESULT("no")
2305         name=`ls testmod.* 2>/dev/null`
2306   fi
2307   if test -n "$name"
2308   then
2309         AC_MSG_CHECKING(Fortran 90 mod name extension)
2310         ext=`echo $name | sed -e 's/^[[^.]]*\.//'`
2311         add_flag 'CMK_MOD_EXT="'$ext'"' "mod name extension"
2312         AC_MSG_RESULT("$ext")
2313         /bin/rm -f $name
2314   fi
2315   /bin/rm -f conftest.f90
2316 fi
2317
2318 AC_OUTPUT(
2319 libs/ck-libs/ampi/ampiCC libs/ck-libs/ampi/ampirun,
2320
2321 chmod +x libs/ck-libs/ampi/ampiCC libs/ck-libs/ampi/ampirun
2322 )