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