Extend FPU POINTER test in configure.ac to check for fpregs
[charm.git] / src / scripts / configure.ac
1 # Decimal representation of Charm++ release line and API revision
2 # Increment the last 2 digits when making an API change
3 # Increase the first three after branching for a release
4
5 AC_INIT(Charm++, 60900, [charm@cs.illinois.edu], charm, [http://charm.cs.illinois.edu/])
6
7 AC_CONFIG_SRCDIR(./Makefile)
8
9 AC_CONFIG_HEADER(conv-autoconfig.h)
10
11 AC_CONFIG_COMMANDS([config-cleanup],
12                    [sed -i -e 's:^#define\s\+PACKAGE://&:' conv-autoconfig.h])
13
14 get_full_command_name()
15 {
16     if test "$(basename "$*")" != "$*"; then
17         echo "$(cd "$(dirname "$*")" && pwd)/$(basename "$*")"
18     else
19         echo "$*"
20     fi
21 }
22
23 ConvSh='../tmp/conv-mach-opt.sh'
24 ConvMak='../tmp/conv-mach-opt.mak'
25
26 #clean up conv-mach-opt.sh
27 sed -e '/Option added by configure/d' "$ConvSh" | sed -e '/^$/d' > conv-mach-opt.sh.clean
28 cp -f conv-mach-opt.sh.clean   "$ConvSh"
29 rm -f conv-mach-opt.sh.clean
30
31 #clean up conv-mach-opt.mak
32 sed -e '/Option added by configure/d' "$ConvMak" | sed -e '/^$/d' > conv-mach-opt.mak.clean
33 cp -f conv-mach-opt.mak.clean   "$ConvMak"
34 rm -f conv-mach-opt.mak.clean
35
36 CHARMINC="."
37 CHARMBIN="../bin"
38 test -r ./conv-config.sh && . ./conv-config.sh
39
40 echo AC_PACKAGE_VERSION > ../include/VERSION
41 AC_DEFINE_UNQUOTED([CHARM_VERSION], AC_PACKAGE_VERSION, [Charm++ Release/API version number])
42
43 charmout="charmconfig.out"
44 /bin/rm -rf $charmout
45 MAKEFILE_EXT=Make.extlib
46
47 Echo() {
48         echo $* 
49         echo $* >> $charmout
50 }
51
52 # add into conv-mach-opt.sh
53 # add_flag $1 $2
54 # $2 is description
55 add_flag() {
56         key=$1
57         key="${key%%=*}"
58         last=`grep -w "$key" "$ConvSh" 2>/dev/null | tail -1 | sed -e 's/ *#.*$//'`
59         skip=0
60         if test -n "$last" -a  "$last" = "$1" 
61         then
62           skip=1
63         fi
64         if test $skip = 0
65         then
66           cat >> "$ConvSh" << EOT
67
68 $1   # Option added by configure script's $2 section
69 EOT
70         fi
71 }
72
73 # remove_flag $1
74 remove_flag() {
75      sed -e '/^'"$1"'=/d' "$ConvSh" > tmp.$$
76      cp tmp.$$ "$ConvSh"
77      /bin/rm -f tmp.$$
78 }
79
80 # add into conv-mach-opt.mak
81 # add_make_flag $1 $2
82 # $2 is description
83 add_make_flag() {
84         key=$1
85         key="${key%%=*}"
86         key="${key%%:*}"
87         last=`grep -w "$key" "$ConvMak" 2>/dev/null | tail -1 | sed -e 's/ *#.*$//'`
88         skip=0
89         if test -n "$last" -a  "$last" = "$1"
90         then
91           skip=1
92         fi
93         if test $skip = 0
94         then
95           # The lack of whitespace around $1 here is necessary.
96           cat >> "$ConvMak" << EOT
97
98 $1# Option added by configure script's $2 section
99 EOT
100         fi
101 }
102
103 # remove_make_flag $1
104 remove_make_flag() {
105      sed -e '/^'"$1"'=/d' "$ConvMak" > tmp.$$
106      cp tmp.$$ "$ConvMak"
107      /bin/rm -f tmp.$$
108 }
109
110 add_flag "OPTS_CC='$OPTS_CC'"   'Pass through user-provided C compiler options'
111 add_flag "OPTS_CXX='$OPTS_CXX'" 'Pass through user-provided C++ compiler options'
112 add_make_flag "CMK_COMPILER:=$CMK_COMPILER" 'basic setup'
113 add_make_flag "CMK_SMP:=$CMK_SMP" 'basic setup'
114 add_make_flag "CMK_SHARED_SUF:=$CMK_SHARED_SUF" 'basic setup'
115 add_make_flag "CMK_NO_PARTITIONS:=$CMK_NO_PARTITIONS" 'basic setup'
116 add_make_flag "CMK_BLUEGENEQ:=$CMK_BLUEGENEQ" 'basic setup'
117 add_make_flag "BUILD_CUDA:=$BUILD_CUDA" 'basic setup'
118
119 # enable/disable error checking
120 AC_ARG_ENABLE([error-checking],
121             [AS_HELP_STRING([--enable-error-checking],
122               [enable error checking])], ,
123             [enable_error_checking=yes])
124
125 if test "$enable_error_checking" = "no"
126 then
127   Echo "Error checking is disabled" 
128   AC_DEFINE_UNQUOTED(CMK_ERROR_CHECKING, 0, [disable error checking])
129   add_flag 'OPTS_CC="$OPTS_CC -U_FORTIFY_SOURCE"' 'error checking'
130   add_flag 'OPTS_CXX="$OPTS_CXX -U_FORTIFY_SOURCE"' 'error checking'
131 else
132   Echo "Error checking is enabled" 
133   AC_DEFINE_UNQUOTED(CMK_ERROR_CHECKING, 1, [enable error checking])
134 fi
135
136 # enable/disable AMPI error checking
137 AC_ARG_ENABLE([ampi-error-checking],
138             [AS_HELP_STRING([--enable-ampi-error-checking],
139               [enable AMPI error checking])], ,
140             [enable_ampi_error_checking=yes])
141
142 if test "$enable_ampi_error_checking" = "no"
143 then
144   Echo "AMPI error checking is disabled"
145   AC_DEFINE_UNQUOTED(AMPI_ERROR_CHECKING, 0, [disable ampi error checking])
146 else
147   Echo "AMPI error checking is enabled"
148   AC_DEFINE_UNQUOTED(AMPI_ERROR_CHECKING, 1, [enable ampi error checking])
149 fi
150
151 # enable/disable statistics collection
152 AC_ARG_ENABLE([stats],
153             [AS_HELP_STRING([--enable-stats],
154               [enable statistics collection])], ,
155             [enable_stats=yes])
156
157 if test "$enable_stats" = "no"
158 then
159   Echo "Statistics collection is disabled" 
160   AC_DEFINE_UNQUOTED(CMK_WITH_STATS, 0, [disable statistics collection])
161 else
162   Echo "Statistics collection is enabled" 
163   AC_DEFINE_UNQUOTED(CMK_WITH_STATS, 1, [enable statistics collection])
164 fi
165
166 # check enable/disable
167 AC_ARG_ENABLE([tracing],
168             [AS_HELP_STRING([--enable-tracing],
169               [enable tracing modules])], ,
170             [enable_tracing=yes])
171
172 if test "$enable_tracing" = "no"
173 then
174   Echo "Charm tracing is disabled"
175   AC_DEFINE_UNQUOTED(CMK_TRACE_ENABLED, 0, [disable tracing])
176   add_flag CMK_TRACE_ENABLED=0
177   add_make_flag 'CMK_TRACE_ENABLED:=0' 'tracing'
178 else
179   Echo "Charm tracing is enabled"
180   AC_DEFINE_UNQUOTED(CMK_TRACE_ENABLED, 1, [enable tracing])
181   add_flag CMK_TRACE_ENABLED=1
182   add_make_flag 'CMK_TRACE_ENABLED:=1' 'tracing'
183 fi
184
185 AC_ARG_ENABLE([tracing-commthread],
186             [AS_HELP_STRING([--enable-tracing-commthread],
187               [enable tracing communication thread])], ,
188             [enable_tracing_commthread=no])
189
190 if test "$enable_tracing_commthread" = "yes"
191 then
192   Echo "Charm tracing communication thread is enabled"
193   AC_DEFINE_UNQUOTED(CMK_SMP_TRACE_COMMTHREAD, 1, [enable tracing comm thread])
194 else
195   Echo "Charm tracing communication thread is disabled"
196   AC_DEFINE_UNQUOTED(CMK_SMP_TRACE_COMMTHREAD, 0, [disable tracing comm thread])
197 fi
198
199
200 # enable task queue
201 AC_ARG_ENABLE([task_queue],
202             [AS_HELP_STRING([--enable-task-queue],
203               [enable task queue])],
204             [enable_task_queue=$enableval],
205             [enable_task_queue=no])
206
207 if test "$enable_task_queue" = "no"
208 then
209   Echo "Task Queue is disabled"
210   AC_DEFINE_UNQUOTED(CMK_TASKQUEUE, 0, [disable task queue])
211 else
212   Echo "Task Queue is enabled"
213   AC_DEFINE_UNQUOTED(CMK_TASKQUEUE, 1, [enable task queue])
214 fi
215
216 # enable drone mode
217 AC_ARG_ENABLE([drone_mode],
218             [AS_HELP_STRING([--enable-drone-mode],
219               [enable drone mode])],
220             [enable_drone_mode=$enableval],
221             [enable_drone_mode=no])
222
223 if test "$enable_drone_mode" = "no"
224 then
225   Echo "Drone mode is disabled"
226   AC_DEFINE_UNQUOTED(CMK_DRONE_MODE, 0, [disable drone mode])
227 else
228   Echo "Drone mode is enabled"
229   AC_DEFINE_UNQUOTED(CMK_DRONE_MODE, 1, [enable drone mode])
230 fi
231
232 AC_ARG_ENABLE([charmdebug],
233             [AS_HELP_STRING([--enable-charmdebug],
234               [enable charmDebug])], ,
235             [enable_charmdebug=yes])
236
237 if test "$enable_charmdebug" = "no" -o "$CMK_CCS_AVAILABLE" = '0'
238 then
239   Echo "CharmDebug is disabled" 
240   AC_DEFINE_UNQUOTED(CMK_CHARMDEBUG, 0, [disable charmdebug])
241   add_flag CMK_CHARMDEBUG=0
242   add_make_flag 'CMK_CHARMDEBUG:=0'
243 else
244   Echo "CharmDebug is enabled" 
245   AC_DEFINE_UNQUOTED(CMK_CHARMDEBUG, 1, [enable charmdebug])
246   add_flag CMK_CHARMDEBUG=1
247   add_make_flag 'CMK_CHARMDEBUG:=1'
248 fi
249
250 AC_ARG_ENABLE([replay],
251             [AS_HELP_STRING([--enable-replay],
252               [enable record/replay])],
253             [enable_replay=$enableval],
254             [enable_replay=yes])
255
256 if test "$enable_replay" = "no"
257 then
258   Echo "Charm record/replay is disabled"
259   AC_DEFINE_UNQUOTED(CMK_REPLAYSYSTEM, 0, [disable replay])
260 else
261   Echo "Charm record/replay is enabled"
262 fi
263
264 AC_ARG_ENABLE([ccs],
265             [AS_HELP_STRING([--enable-ccs],
266               [enable CCS])], ,
267             [enable_ccs=yes])
268
269 if test "$enable_ccs" = "no" -o "$CMK_CCS_AVAILABLE" = '0'
270 then
271   Echo "CCS is disabled" 
272   AC_DEFINE_UNQUOTED(CMK_CCS_AVAILABLE, 0, [disable ccs])
273 else
274   Echo "CCS is enabled" 
275   AC_DEFINE_UNQUOTED(CMK_CCS_AVAILABLE, 1, [enable ccs])
276 fi
277
278 AC_ARG_ENABLE([controlpoint],
279             [AS_HELP_STRING([--enable-controlpoint],
280               [enable control point])],
281             [enable_controlpoint=$enableval],
282             [enable_controlpoint=yes])
283
284 if test "$enable_controlpoint" = "yes"
285 then
286   Echo "Charm control point is enabled"
287   AC_DEFINE_UNQUOTED(CMK_WITH_CONTROLPOINT, 1, [enable controlpoint])
288 else
289   Echo "Charm control point is disabled"
290   AC_DEFINE_UNQUOTED(CMK_WITH_CONTROLPOINT, 0, [disable controlpoint])
291 fi
292
293 AC_ARG_ENABLE([lbuserdata],
294             [AS_HELP_STRING([--enable-lbuserdata],
295               [enable LB user data])],
296             [enable_lbuserdata=$enableval],
297             [enable_lbuserdata=no])
298
299 if test "$enable_lbuserdata" = "yes"
300 then
301   Echo "Charm LB user data is enabled"
302   AC_DEFINE_UNQUOTED(CMK_LB_USER_DATA, 1, [enable lb user data])
303 else
304   Echo "Charm LB user data  is disabled"
305   AC_DEFINE_UNQUOTED(CMK_LB_USER_DATA, 0, [disable lb user data])
306 fi
307
308 AC_ARG_ENABLE([lockless-queue],
309             [AS_HELP_STRING([--enable-lockless-queue],
310               [enable lockless queue for PE local and node queue])],
311             [enable_lockless_queue=$enableval],
312             [enable_lockless_queue=no])
313
314 if test "$enable_lockless_queue" = "no"
315 then
316   Echo "Lockless queue for PE local and node queue is disabled"
317   AC_DEFINE_UNQUOTED(CMK_LOCKLESS_QUEUE, 0, [disable lockless queue for pe/node queue])
318 else
319   Echo "Lockless queue for PE local and node queue is enabled"
320   AC_DEFINE_UNQUOTED(CMK_LOCKLESS_QUEUE, 1, [enable lockless queue for pe/node queue])
321 fi
322
323
324 AC_ARG_ENABLE([shrinkexpand],
325             [AS_HELP_STRING([--enable-shrinkexpand],
326               [enable malleable jobs / shrink expand])],
327             [enable_shrinkexpand=$enableval],
328             [enable_shrinkexpand=no])
329
330 if test "$enable_shrinkexpand" = "yes"
331 then
332   if test "$enable_ccs" = "no"
333   then
334     Echo "CCS cannot be disabled when enabling shrink-expand"
335     test_finish 1
336   else
337     Echo "Charm shrink expand is enabled - Controlpoint is disabled."
338     AC_DEFINE_UNQUOTED(CMK_SHRINK_EXPAND, 1, [enable shrinkexpand])
339     AC_DEFINE_UNQUOTED(CMK_WITH_CONTROLPOINT, 0, [disable controlpoint])
340   fi
341 else
342   Echo "Charm shrink expand is disabled"
343   AC_DEFINE_UNQUOTED(CMK_SHRINK_EXPAND, 0, [disable shrinkexpand])
344 fi
345
346 AC_ARG_ENABLE([charmpy],
347             [AS_HELP_STRING([--enable-charmpy],
348               [enable charm4py support])],
349             [enable_charmpy=$enableval],
350             [enable_charmpy=no])
351
352 if test "$enable_charmpy" = "yes"
353 then
354   Echo "charm4py support is enabled"
355   AC_DEFINE_UNQUOTED(CMK_CHARMPY, 1, [enable charmpy])
356 else
357   Echo "charm4py support is disabled"
358   AC_DEFINE_UNQUOTED(CMK_CHARMPY, 0, [disable charmpy])
359 fi
360
361 AC_ARG_WITH([numa],
362             [AS_HELP_STRING([--with-numa],
363               [support memory affinity with NUMA])],
364             [],
365             [with_numa=no])
366
367 WITH_NUMA=no
368 if test "$with_numa" = "yes"
369 then
370   Echo "Charm NUMA support is builtin"
371   WITH_NUMA=yes
372 fi
373
374 AC_ARG_WITH([lbtime-type],
375             [AS_HELP_STRING([--with-lbtime-type=type],
376                             [load balancing timer type])],
377             [], [with_lbtime_type=double])
378
379 if test "$with_lbtime_type" = "float" -o "$with_lbtime_type" = "double"
380 then
381   Echo "Setting load balancing timer type as '$with_lbtime_type'"
382   AC_DEFINE_UNQUOTED(CMK_LBTIME_TYPE, $with_lbtime_type, [Setting load balancing timer type])
383 else
384   Echo "Invalid type specified for load balancing timer type"
385   test_finish 1
386 fi
387
388 AC_DEFINE_UNQUOTED(CMK_LBID_64BIT, 1, [enable 64 bit LB ID])
389
390 AC_DEFINE_UNQUOTED(CMK_CKSECTIONINFO_STL, 1, [enable STL CkSectionInfo])
391
392 AC_ARG_WITH([qlogic],
393             [AS_HELP_STRING([--with-qlogic],
394               [QLogic based Infiniband])],[with_qlogic=yes],
395             [with_qlogic=no])
396
397 if test "$with_qlogic" = "no"
398 then
399   AC_DEFINE_UNQUOTED(QLOGIC, 0, [disable qlogic])
400 else
401   Echo "QLogic based Infiniband"
402   AC_DEFINE_UNQUOTED(QLOGIC, 1, [enable qlogic])
403 fi
404
405 #
406 AC_MSG_CHECKING(machine name)
407 version=`pwd | awk -F/ '{print $(NF-1)}'`
408 base_version="$CMK_VDIR"
409 AC_DEFINE_UNQUOTED(CMK_MACHINE_NAME, "$version",[machine name])
410 AC_MSG_RESULT($version)
411 AC_SUBST(base_version)
412
413 t="test.cpp"
414 tc="test.c"
415
416 # test result passed in $1
417 # If the test suceeded, print $3 and set "pass"/clear "fail"
418 # If the test failed, print $2 and clear "pass"/set "fail"
419 test_result() {
420         if test $1 -eq 0
421         then
422                 AC_MSG_RESULT("$3")
423                 pass="1"
424                 fail="0"
425         else
426                 AC_MSG_RESULT("$4")
427                 pass="0"
428                 fail="1"
429 # For debugging the configure script, just "export autoconf_debug=1"
430 #  to get this verbose data on any failed tests:
431                 if test ! -z "$autoconf_debug"
432                 then
433                         echo "------- test script for $2 failed:"
434                         cat out
435                         echo "------- the test program was:"
436                         cat $t
437                         echo "-------"
438                 fi
439         fi
440 }
441
442 # Test: tries to compile C file $t (described by $1).
443 #  If successful, prints $2 and sets $pass/clears $fail
444 #  If failure, prints $3 and sets $pass/clears $fail
445 #  additional arguments to c++ compiler are passed as $4
446 test_cc() {
447         AC_MSG_CHECKING("$1")
448         echo "### $1" >> $charmout
449         cat $tc >> $charmout
450         echo $CMK_CC $CMK_CC_FLAGS -I../include -I. $CMK_INCDIR $CMK_SYSINC $OPTS_CC -c $tc -o test.o $4 >> $charmout
451         $CMK_CC $CMK_CC_FLAGS -I../include -I. $CMK_INCDIR $CMK_SYSINC $OPTS_CC -c $tc -o test.o $4 > out 2>&1
452         test_result $? "$1" "$2" "$3"
453         strictpass=$pass
454         strictfail=$fail
455         if test $pass -eq 1
456         then 
457           if grep -i "warn" out > /dev/null 2>&1 || grep -i "(W)" out > /dev/null 2>&1
458           then 
459             strictpass="0" && strictfail="1"
460           fi
461         fi
462         cat out >> $charmout
463         /bin/rm -f out
464 }
465
466 # Test: tries to compile C++ file $t (described by $1).
467 #  If successful, prints $2 and sets $pass/clears $fail
468 #  If failure, prints $3 and sets $pass/clears $fail
469 #  additional arguments to c++ compiler are passed as $4
470 test_cxx() {
471         AC_MSG_CHECKING("$1")
472         echo "### $1" >> $charmout
473         cat $t >> $charmout
474         echo $CMK_CXX $CMK_CXX_FLAGS -I../include -I. $CMK_INCDIR $CMK_SYSINC $OPTS_CXX -c $t -o test.o $4 >> $charmout
475         $CMK_CXX $CMK_CXX_FLAGS -I../include -I. $CMK_INCDIR $CMK_SYSINC $OPTS_CXX -c $t -o test.o $4 > out 2>&1
476         test_result $? "$1" "$2" "$3"
477         strictpass=$pass
478         strictfail=$fail
479         if test $pass -eq 1
480         then 
481           if grep -i "warn" out > /dev/null 2>&1 || grep -i "(W)" out > /dev/null 2>&1
482           then 
483             strictpass="0" && strictfail="1"
484           fi
485         fi
486         cat out >> $charmout
487         /bin/rm -f out
488 }
489
490 # Test: tries to compile C++ file $t (described by $1) using native compiler.
491 #  If successful, prints $2 and sets $pass/clears $fail
492 #  If failure, prints $3 and sets $pass/clears $fail
493 #  additional arguments to c++ compiler are passed as $4
494 test_native_cxx() {
495         AC_MSG_CHECKING("$1")
496         echo "### $1" >> $charmout
497         cat $t >> $charmout
498         echo $CMK_NATIVE_CXX $CMK_NATIVE_CXX_FLAGS -I../include -I. $CMK_INCDIR $CMK_SYSINC $OPTS_CXX -c $t -o test.o $4 >> $charmout
499         $CMK_NATIVE_CXX $CMK_NATIVE_CXX_FLAGS -I../include -I. $CMK_INCDIR $CMK_SYSINC $OPTS_CXX -c $t -o test.o $4 > out 2>&1
500         test_result $? "$1" "$2" "$3"
501         strictpass=$pass
502         strictfail=$fail
503         if test $pass -eq 1
504         then
505           if grep -i "warn" out > /dev/null 2>&1 || grep -i "(W)" out > /dev/null 2>&1
506           then
507             strictpass="0" && strictfail="1"
508           fi
509         fi
510         cat out >> $charmout
511         /bin/rm -f out
512 }
513
514 # Testlink: tries to compile and link a C++ file $t (described by $1).
515 #  If successful, prints $2 and sets $pass/clears $fail
516 #  If failure, prints $3 and sets $pass/clears $fail
517 #  additional arguments to c++ compiler are passed as $4
518 test_link() {
519         AC_MSG_CHECKING("$1")
520         echo "### $1" >> $charmout
521         cat $t >> $charmout
522         echo $CMK_CXX $CMK_CXX_FLAGS -I../include -I. $CMK_INCDIR $CMK_SYSINC $OPTS_CXX -c $t -o test.o $4 >> $charmout
523         $CMK_CXX $CMK_CXX_FLAGS -I../include -I. $CMK_INCDIR $CMK_SYSINC $OPTS_CXX -c $t -o test.o $4 > out 2>&1
524         if test $? -ne 0
525         then
526           test_result 1 "$1" "$2" "$3"
527         else
528           echo $CMK_LDXX $CMK_LDXX_FLAGS $CMK_LINK_BINARY -o testlink test.o $CMK_LIBDIR $OPTS_LD $CMK_SYSLIBS $4 $5 >> $charmout
529           $CMK_LDXX $CMK_LDXX_FLAGS $CMK_LINK_BINARY -o testlink test.o $CMK_LIBDIR $OPTS_LD $CMK_SYSLIBS $4 $5 >> out 2>&1
530           ret=$?
531           test ! -x testlink && ret=1
532           test_result $ret "$1" "$2" "$3"
533         fi
534         strictpass=$pass
535         strictfail=$fail
536         if test $pass -eq 1
537         then 
538           if cat out | grep -i "warn" > /dev/null 2>&1
539           then 
540             strictpass="0" && strictfail="1"
541           fi
542         fi
543         cat out >> $charmout
544         /bin/rm -f out
545 }
546
547 # Testlinkc: tries to compile and link a C file $t (described by $1).
548 #  If successful, prints $2 and sets $pass/clears $fail
549 #  If failure, prints $3 and sets $pass/clears $fail
550 #  additional arguments to c++ compiler are passed as $4
551 test_linkc() {
552         AC_MSG_CHECKING("$1")
553         echo "### $1" >> $charmout
554         cat $tc >> $charmout
555         echo $CMK_CC $CMK_CC_FLAGS -I../include -I. $CMK_INCDIR $CMK_SYSINC $OPTS_CC -c $tc -o test.o $4 >> $charmout
556         $CMK_CC $CMK_CC_FLAGS -I../include -I. $CMK_INCDIR $CMK_SYSINC $OPTS_CC -c $tc -o test.o $4 > out 2>&1
557         if test $? -ne 0
558         then
559           test_result 1 "$1" "$2" "$3"
560         else
561           echo $CMK_LD $CMK_LD_FLAGS $CMK_LINK_BINARY -o testlink test.o $CMK_LIBDIR $OPTS_LD $CMK_SYSLIBS $4 >> $charmout
562           $CMK_LD $CMK_LD_FLAGS $CMK_LINK_BINARY -o testlink test.o $CMK_LIBDIR $OPTS_LD $CMK_SYSLIBS $4 >> out 2>&1
563           test_result $? "$1" "$2" "$3"
564         fi
565         strictpass=$pass
566         strictfail=$fail
567         if test $pass -eq 1
568         then 
569           if cat out | grep -i "warn" > /dev/null 2>&1
570           then 
571             strictpass="0" && strictfail="1"
572           fi
573         fi
574         cat out >> $charmout
575         /bin/rm -f out
576 }
577
578 # test_linkso $1 $2 $3 $4, where
579 # $1: debug msg
580 # $2: yes msg
581 # $3: no msg
582 # $4: extra link option
583 test_linkso() {
584         AC_MSG_CHECKING("$1")
585         echo $1 >> $charmout
586         cat $t >> $charmout
587         echo $CMK_CXX $CMK_CXX_FLAGS -I../include -I. $CMK_INCDIR $CMK_SYSINC $OPTS_CXX $CMK_PIC -c $t -o test.o $4 >> $charmout
588         $CMK_CXX $CMK_CXX_FLAGS -I../include -I. $CMK_INCDIR $CMK_SYSINC $OPTS_CXX -c $CMK_PIC $t -o test.o $4 > out 2>&1
589         if test $? = 1
590         then
591           test_result 1 "$1" "$2" "$3"
592         else
593           echo $CMK_LD $CMK_LD_FLAGS $CMK_LIBDIR $OPTS_LD $CMK_LD_SHARED $CMK_SYSLIBS test.o -o testlink.$CMK_SHARED_SUF $4 >> $charmout
594           $CMK_LD $CMK_LD_FLAGS $CMK_LIBDIR $OPTS_LD $CMK_LD_SHARED $CMK_SYSLIBS test.o -o testlink.$CMK_SHARED_SUF $4 > out 2>&1
595           test_result $? "$1" "$2" "$3"
596         fi
597         cat out >> $charmout
598         /bin/rm -f out testlink.$CMK_SHARED_SUF
599 }
600
601 test_finish() {
602         rm -f $t $tc testlink test.o    > /dev/null 2>&1
603         /bin/rm -f out
604         test $1 -eq 1 && echo "*** Please find detailed output in tmp/charmconfig.out ***"
605         exit $1
606 }
607
608 # detect certain architectures
609 if cat /proc/cpuinfo 2>/dev/null | grep 'POWER7'  > /dev/null
610 then
611   AC_DEFINE_UNQUOTED(CMK_POWER7, 1, [whether is power7])
612 fi
613
614 # detect OS
615 OSNAME=`uname -s`
616 if test $OSNAME = "Linux"
617 then
618   AC_DEFINE_UNQUOTED(CMK_OS_IS_LINUX, 1, [OS is Linux])
619 else
620   AC_DEFINE_UNQUOTED(CMK_OS_IS_LINUX, 0, [OS is Linux])
621 fi
622
623 # test cp -p
624 AC_MSG_CHECKING("cp command as")
625 CP="cp -p"
626 touch test_file
627 if ! $CP test_file test_file.cp 2>err
628 then
629   CP="cp"
630 fi
631 rm -f test_file test_file.cp
632 AC_MSG_RESULT($CP)
633 add_flag CP=\""$CP"\" "cp command"
634  
635
636 cat > $t <<EOT
637 #include <stdio.h>
638 void foo(void) {
639         printf("Hello, world!\n");
640 }
641 EOT
642
643 if test "$CMK_BUILD_CRAY" = "1"
644 then
645 #echo "Test for known incompatible compiler versions"
646
647  if test "$CRAY_CC_VERSION" = "8.1.4"
648  then
649         echo "CCE 8.1.4 produces incorrect Charm++ code"
650         echo "Please use a newer version of the CCE compiler"
651         echo "e.g. module load cce/8.1.7"
652         test_finish 1
653  fi
654 fi
655
656 #echo "set C++ compiler as: $CMK_CXX $OPTS_CXX $OPTS"
657 AC_MSG_CHECKING("C++ compiler as")
658 AC_MSG_RESULT("$CMK_CXX $OPTS_CXX")
659 test_cxx "whether C++ compiler works" "ok" "no" ""
660 if test $fail -eq 1
661 then
662         echo "Cannot compile C++ programs with $CMK_CXX"
663         echo " (check your charm++ version)"
664         test_finish 1
665 fi
666
667 cat > $t <<EOT
668 #include <stdio.h>
669 int main() {
670         printf("Hello, world!\n");
671         return 0;
672 }
673 EOT
674 #echo "set C++ linker as: $CMK_LDXX $OPTS_LD"
675 AC_MSG_CHECKING("C++ linker as")
676 AC_MSG_RESULT("$CMK_LDXX $OPTS_LD")
677 test_link "whether linker works" "ok" "no" ""
678 if test $fail -eq 1
679 then
680         echo "Cannot link C++ programs with $CMK_LDXX"
681         echo " (check your charm++ version)"
682         test_finish 1
683 fi
684
685 AC_MSG_CHECKING("Native C++ compiler as")
686 AC_MSG_RESULT("$CMK_NATIVE_CXX")
687 AC_MSG_CHECKING("Sequential C++ compiler as")
688 AC_MSG_RESULT("$CMK_SEQ_CXX")
689
690 if echo "$CMK_CC" | grep -E "gcc|clang|icc" > /dev/null 2> /dev/null
691 then
692   test_link "whether compiler accept -fno-stack-protector" "ok" "no" "-fno-stack-protector"
693   if test $strictpass -eq 1
694   then
695         add_flag OPTS_CC='"$OPTS_CC -fno-stack-protector"' "stack-protection disabling"
696         add_flag OPTS_CXX='"$OPTS_CXX -fno-stack-protector"' "stack-protection disabling"
697   fi
698 fi
699
700 #### check if C++ compiler will accept C++11 features without warning ####
701 cat > $t <<EOT
702 // Check for Intel compiler incompatibility with the active g++/libstdc++ by
703 // including an arbitrary standard library header (cf bug #1560)
704 #include <map>
705
706 // Check for an excessively old g++/libstdc++ that can't handle features we use
707 #include <memory>
708 #include <vector>
709 std::unique_ptr<int> i;
710
711 class CkMigrateMessage;
712
713 struct base {
714   base(void) { }
715   base(CkMigrateMessage *) { }
716 };
717
718 template <class Parent>
719 struct CBaseT1 : Parent {
720   std::vector<int> v; // check for C++11's shrink_to_fit()
721
722   CBaseT1(void) :Parent()  { v.shrink_to_fit(); }
723   CBaseT1(CkMigrateMessage *m) :Parent(m) { }
724   CBaseT1(CBaseT1&& rhs) :Parent() { }
725
726   template <typename... Args>
727     CBaseT1(Args... args) : Parent(args...) { }
728 };
729
730 template struct CBaseT1<base>;
731 EOT
732 got_cpp11=""
733 test_cxx "whether C++ compiler supports C++11 without flags" "yes" "no" ""
734 if test $strictpass -eq 1
735 then
736   got_cpp11="true"
737 else
738 # Flags for g++/clang++/icpc/xlC++, pgCC, and CrayCC respectively
739 for i in "-std=c++11" "--c++11" "-h std=c++11"; do
740     test_cxx "whether C++ compiler supports C++11 with '$i'" "yes" "no" "$i"
741     if test $strictpass -eq 1
742     then
743       add_flag "$(echo OPTS_CXX=\"\$OPTS_CXX $i\")" "Enable C++11 support"
744       OPTS_CXX="$OPTS_CXX $i"
745       got_cpp11="true"
746       break
747     fi
748 done
749 fi
750
751 if test -z $got_cpp11
752 then
753   echo "Charm++ requires C++11 support, but doesn't know the flag to enable it"
754   echo
755   echo "For Intel's compiler please see"
756   echo "https://charm.cs.illinois.edu/redmine/issues/1560"
757   echo "about making a suitable version of gcc/g++/libstdc++ available"
758   echo
759   echo "For Blue Gene/Q please use the Clang compiler"
760   test_finish 1
761 fi
762
763 test_native_cxx "whether native C++ compiler supports C++11 without flags" "yes" "no" ""
764 if test $strictpass -ne 1
765 then
766   # Flags for g++/clang++/icpc/xlC++, pgCC, and CrayCC respectively
767   for i in "-std=c++11" "--c++11" "-h std=c++11"; do
768     test_native_cxx "whether C++ compiler supports C++11 with '$i'" "yes" "no" "$i"
769     if test $strictpass -eq 1
770     then
771       add_flag "$(echo CMK_NATIVE_CXX_FLAGS=\"\$CMK_NATIVE_CXX_FLAGS $i\")" "Enable C++11 support"
772       break
773     fi
774 done
775 fi
776
777 # Workaround for bug #1045 appearing in GCC >6.x
778 test_cxx "whether C++ compiler accepts -fno-lifetime-dse" "yes" "no" "-fno-lifetime-dse"
779 if test $strictpass -eq 1
780 then
781     add_flag "$(echo OPTS_CXX=\"\$OPTS_CXX -fno-lifetime-dse\")" "Disable 'Lifetime DSE' optimization to work around bug #1045 in GCC >6.x"
782     OPTS_CXX="$OPTS_CXX -fno-lifetime-dse"
783 fi
784
785 # Test for a flag tlsglobals sometimes depends on
786 test_cxx "whether C++ compiler accepts -mno-tls-direct-seg-refs" "yes" "no" "-mno-tls-direct-seg-refs"
787 if test $strictpass -eq 1
788 then
789     add_flag 'CMK_COMPILER_KNOWS_TLSDIRECTSEGREFS="1"' "tlsglobals"
790 fi
791
792 # Determine compiler/linker flags to build libcharm.so for charm4py
793 if test "$enable_charmpy" = "yes"
794 then
795
796   cat > $t <<EOT
797 int main() { return 0; }
798 EOT
799
800   test_cxx "whether C++ compiler accepts --no-as-needed" "yes" "no" "--no-as-needed"
801   if test $strictpass -eq 1
802   then
803       add_flag "$(echo CXX_NO_AS_NEEDED=\"--no-as-needed\")" "--no-as-needed flag necessary for compilers that default to linking with --as-needed"
804   fi
805
806   got_opt_whole_archive=""
807   # Flags for g++/clang++/icpc, Apple-LLVM respectively
808   for i in "-Wl,--whole-archive -Wl,--no-whole-archive" "-Wl,-all_load"; do
809       test_link "whether linker supports '$i'" "yes" "no" "" "$i"
810       if test $strictpass -eq 1
811       then
812         got_opt_whole_archive="true"
813         IFS=' ' read LDXX_WHOLE_ARCHIVE_PRE LDXX_WHOLE_ARCHIVE_POST <<< $i
814         add_flag "$(echo LDXX_WHOLE_ARCHIVE_PRE=\"$LDXX_WHOLE_ARCHIVE_PRE\")" "Flags to link whole archives into libcharm.so"
815         add_flag "$(echo LDXX_WHOLE_ARCHIVE_POST=\"$LDXX_WHOLE_ARCHIVE_POST\")" "Flags to link whole archives into libcharm.so"
816         break
817       fi
818   done
819
820   if test -z $got_opt_whole_archive
821   then
822     echo "Don't know how to build libcharm.so for Charm4py"
823     test_finish 1
824   fi
825 fi
826
827 # Figure out if the user has asked to enable the latest language standards
828 USER_ASKED_FOR_NEW_STD=`echo "$BUILDOPTS" | grep "\-use-new-std" | wc -l`
829
830 # If the user has asked for the newer standards, check if the compilers know about them
831 if test $USER_ASKED_FOR_NEW_STD -ge 1
832 then
833
834 #### check if c compiler supports c11 compilation flags ####
835 cat > $tc <<EOT
836 #include <stdio.h>
837
838 int foo()
839 {
840   return 0;
841 }
842 EOT
843 test_cc "whether c compiler knows of the c11 standard" "ok" "no" "$CMK_ENABLE_C11"
844 AC_DEFINE_UNQUOTED(CMK_COMPILER_KNOWS_C11, $pass, [whether c compiler knows of the c11 standard] )
845 if test $pass -eq 1
846 then
847         # Record results for charmc's future use
848         add_flag 'CMK_COMPILER_KNOWS_C11="1"' "c11"
849         # For the rest of configure, append this to compilation flags
850         OPTS_CC="$CMK_ENABLE_C11 $OPTS_CC"
851 fi
852 fi # endif USER_ASKED_FOR_NEW_STD
853
854 # Perform the tests
855
856 AC_ARG_WITH([refnum-type],
857             [AS_HELP_STRING([--with-refnum-type=type],
858                             [size of the envelope refnum field])],
859             [], [with_refnum_type=no])
860
861 if test "$with_refnum_type" = "no" -o "$with_refnum_type" = "short"
862 then
863   Echo "Setting charm++ envelope refnum field to unsigned short"
864   AC_DEFINE_UNQUOTED(CMK_REFNUM_TYPE, unsigned short, [envelope refnum field set to UShort])
865 elif test "$with_refnum_type" = "int"
866 then
867   Echo "Setting charm++ envelope refnum field to unsigned int"
868   AC_DEFINE_UNQUOTED(CMK_REFNUM_TYPE, unsigned int, [envelope refnum field set to UInt])
869 else
870   Echo "Invalid size specified for refnum field"
871   test_finish 1
872 fi
873
874
875 AC_ARG_WITH([prio-type],
876             [AS_HELP_STRING([--with-prio-type=type],
877                             [size of expected message priorities])],
878             [], [with_prio_type=bitvec])
879
880 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"
881 then
882   Echo "Configuring support for message priorities of sizeof type $with_prio_type"
883   AC_DEFINE_UNQUOTED(CMK_USE_STL_MSGQ, 1, [whether charm scheduler should use an STL-based msg q])
884   AC_DEFINE_UNQUOTED(CMK_MSG_PRIO_TYPE, $with_prio_type, [expected message priorities are sizeof $with_prio_type])
885 elif test "$with_prio_type" = "bitvec"
886 then
887   Echo "Configuring support for message priorities of arbitrary size (bitvectors)"
888   AC_DEFINE_UNQUOTED(CMK_USE_STL_MSGQ, 0, [whether charm scheduler should use an STL-based msg q])
889   AC_DEFINE_UNQUOTED(CMK_MSG_PRIO_TYPE, $with_prio_type, [expected message priorities are arbitrarily sized])
890 else
891   Echo "Invalid size ($with_prio_type) specified for message priorities. Can only accept char, short, int, long, float, double and bitvec"
892   test_finish 1
893 fi
894
895 # enable/disable randomized scheduler queue
896 AC_ARG_ENABLE([randomized-msgq],
897             [AS_HELP_STRING([--enable-randomized-msgq],
898               [enable a randomized msg queue (for debugging etc)])], ,
899             [enable_randomized_msgq=no])
900
901 if test "$enable_randomized_msgq" = "yes" -a "$with_prio_type" != "bitvec"
902 then
903   Echo "The charm message queue will be randomized (and will not respect priorities)"
904   AC_DEFINE_UNQUOTED(CMK_RANDOMIZED_MSGQ, 1, [enable the randomized msgq in the scheduler])
905 else
906   AC_DEFINE_UNQUOTED(CMK_RANDOMIZED_MSGQ, 0, [disable the randomized msgq in the scheduler])
907   if test "$enable_randomized_msgq" = "yes"
908   then
909     Echo 'A randomized message queue is only available when --with-prio-type != bitvec.'
910     Echo "Specify prio-type to be a data type long enough to hold the message priorities in your application"
911     Echo "for example: --with-prio-type=int (or short / long etc)."
912     test_finish 1
913   fi
914 fi
915
916 AC_ARG_WITH([mempool-cutoff],
917             [AS_HELP_STRING([--with-mempool-cutoff=N],
918                             [exponent of the maximum power of two to use for bin sizes in the mempool])],
919             [], [with_mempool_cutoff=26])
920
921 if test "$((6 < $with_mempool_cutoff && $with_mempool_cutoff < 32))" = '1'
922 then
923   Echo "Using mempool cutoff... 2^$with_mempool_cutoff"
924   AC_DEFINE_UNQUOTED(CMK_MEMPOOL_CUTOFFNUM, $((with_mempool_cutoff - 6)), [mempool cutoff])
925 else
926   Echo "Invalid number ($with_mempool_cutoff) specified for mempool cutoff. Valid range: 7 <= N <= 31"
927   test_finish 1
928 fi
929
930 # enable mpich tests
931 AC_ARG_ENABLE([ampi-mpich-tests],
932             [AS_HELP_STRING([--enable-ampi-mpich-tests],
933             [enable mpich tests for ampi])],
934             [enable_ampi_mpich_tests=yes],
935             [enable_ampi_mpich_tests=no])
936
937 if test "$enable_ampi_mpich_tests" = "yes"
938 then
939   AC_DEFINE([AMPI_ERRHANDLER_RETURN], [1], [enable ampi fatal error return])
940   add_make_flag "BUILD_MPICH_TESTS:=true" 'mpich tests setup'
941 else
942   AC_DEFINE([AMPI_ERRHANDLER_RETURN], [0], [disable ampi fatal error return])
943 fi
944
945 #### Check if compiler is 64 bit ####
946 cat > $t <<EOT
947 #include <stdio.h>
948
949 int foo()
950 {
951 int x[[(int)(sizeof(void *) - 7)]]={0};
952 return x[[0]];
953 }
954 EOT
955 test_cxx "whether compiler generates code for 64-bit" "yes" "no" ""
956 AC_DEFINE_UNQUOTED(CMK_SIZET_64BIT, $strictpass, [whether size_t 64bit])
957 in64bit=$strictpass
958
959 ### Check if compiler supports std::is_constructible<> ###
960 cat > $t <<EOT
961 #include <type_traits>
962
963 struct s {
964        s(int a) { }
965 };
966
967 bool foo()
968 {
969   return std::is_constructible<s, int>::value;
970 }
971 EOT
972 test_cxx "whether compiler supports std::is_constructible" "yes" "no" ""
973 AC_DEFINE_UNQUOTED(CMK_HAS_IS_CONSTRUCTIBLE, $strictpass, [whether compiler supports std::is_constructible])
974
975 ### Check if compiler supports std::alignment_of<> ###
976 cat > $t <<EOT
977 #include <type_traits>
978
979 int foo()
980 {
981   return std::alignment_of<int>::value;
982 }
983 EOT
984 test_cxx "whether compiler supports std::alignment_of" "yes" "no" ""
985 AC_DEFINE_UNQUOTED(CMK_HAS_ALIGNMENT_OF, $strictpass, [whether compiler supports std::alignment_of])
986
987 ### Check if compiler implements regex ###
988 cat > $t <<EOT
989 #include <regex>
990 void foo()
991 {
992 #if __cplusplus >= 201103L &&                             \
993     (!defined(__GLIBCXX__) || (__cplusplus >= 201402L) || \
994         (defined(_GLIBCXX_REGEX_DFS_QUANTIFIERS_LIMIT) || \
995          defined(_GLIBCXX_REGEX_STATE_LIMIT)           || \
996              (defined(_GLIBCXX_RELEASE)                && \
997              _GLIBCXX_RELEASE > 4)))
998 // compiler has regex support, continue
999 #else
1000 // force compilation to fail
1001 static_assert(false, "compiler has no regex implementation");
1002 #endif
1003 }
1004 EOT
1005 test_cxx "whether compiler implements regex" "yes" "no" ""
1006 AC_DEFINE_UNQUOTED(CMK_HAS_REGEX, $pass, [whether compiler implements regex])
1007
1008 #### test if has values.h ####
1009 cat > $t <<EOT
1010 #include <values.h>
1011 int main() { 
1012   double d = MAXDOUBLE;
1013   return 0;
1014 }
1015 EOT
1016 test_cxx "whether has values.h " "yes" "no" ""
1017 AC_DEFINE_UNQUOTED(CMK_HAS_VALUES_H, $pass, [whether has values.h])
1018
1019 #### test if has stdint.h ####
1020 cat > $t <<EOT
1021 #include <stdint.h>
1022 int main() { 
1023   return 0;
1024 }
1025 EOT
1026 test_cxx "whether has stdint.h " "yes" "no" ""
1027 AC_DEFINE_UNQUOTED(CMK_HAS_STDINT_H, $pass, [whether has stdint.h])
1028
1029 #### test if has malloc.h ####
1030 cat > $t <<EOT
1031 #include <malloc.h>
1032 int main() { 
1033   return 0;
1034 }
1035 EOT
1036 test_cxx "whether has malloc.h " "yes" "no" ""
1037 AC_DEFINE_UNQUOTED(CMK_HAS_MALLOC_H, $pass, [whether has malloc.h])
1038
1039 #### test if has alloca.h ####
1040 cat > $t <<EOT
1041 #include <alloca.h>
1042 int main() {
1043   double *s=(double *)alloca(sizeof(double));
1044   *s=1.0;
1045   return 0;
1046 }
1047 EOT
1048 test_cxx "whether has alloca.h " "yes" "no" ""
1049 AC_DEFINE_UNQUOTED(CMK_HAS_ALLOCA_H, $pass, [whether has alloca.h])
1050
1051 #### test if has regex.h ####
1052 cat > $t <<EOT
1053 #include <regex.h>
1054 int main() {
1055   regex_t re;
1056   regcomp(&re, ".*MOD.*", REG_EXTENDED|REG_NOSUB);
1057   return 0;
1058 }
1059 EOT
1060 test_cxx "whether has regex.h " "yes" "no" ""
1061 AC_DEFINE_UNQUOTED(CMK_HAS_REGEX_H, $pass, [whether has regex.h])
1062
1063 #### Check long long ####
1064 cat > $t <<EOT
1065 #include <stdlib.h>
1066 long long foo(void) { return 17; }
1067 EOT
1068 test_cxx "whether long long works" "yes" "no" ""
1069 AC_DEFINE_UNQUOTED(CMK_LONG_LONG_DEFINED, $pass, [whether long long works])
1070
1071 #### Check __int64 ####
1072 cat > $t <<EOT
1073 #include <stdlib.h>
1074 __int64 foo(void) { return 17; }
1075 EOT
1076 test_cxx "whether __int64 works" "yes" "no" ""
1077 AC_DEFINE_UNQUOTED([CMK___int64_DEFINED], $pass, [whether __int64 works])
1078
1079
1080 CMK_HAS_INT16=0
1081
1082 #### Check __int128 ####
1083 cat > $t <<EOT
1084 #include <stdlib.h>
1085 int foo(void) {
1086   __int128   a;
1087   int x[[(int)(sizeof(__int128) - 15)]]={0};
1088   return x[[0]];
1089 }
1090 EOT
1091 test_cxx "whether __int128 (128-bit integer) works" "yes" "no" ""
1092 AC_DEFINE_UNQUOTED([CMK___int128_DEFINED], $pass, [whether __int128 works])
1093 if test $pass -eq 1
1094 then
1095   CMK_HAS_INT16=1
1096   add_flag CMK_HAS_INT16=1
1097 fi
1098
1099 #### Check __int128_t ####
1100 cat > $t <<EOT
1101 #include <stdlib.h>
1102 int foo(void) {
1103   __int128_t   a;
1104   __uint128_t   b;
1105   a = a + a;
1106   int x[[(int)(sizeof(__int128_t) - 15)]]={0};
1107   return x[[0]];
1108 }
1109 EOT
1110 test_cxx "whether __int128_t (128-bit integer) works" "yes" "no" ""
1111 AC_DEFINE_UNQUOTED([CMK___int128_t_DEFINED], $pass, [whether __int128_t works])
1112 if test $pass -eq 1
1113 then
1114   CMK_HAS_INT16=1
1115   add_flag CMK_HAS_INT16=1
1116 fi
1117
1118 #### Summarize *int128* ####
1119
1120 AC_DEFINE_UNQUOTED([CMK_HAS_INT16], $CMK_HAS_INT16, [whether any 128-bit integer works])
1121
1122
1123 ### Check if we have C++11 <atomic> ###
1124 cat > $t <<EOT
1125 #include <atomic>
1126 int main(int argc, char** argv) { 
1127   return 0;
1128 }
1129 EOT
1130 test_cxx "whether C++ library has <atomic> " "yes" "no" ""
1131 AC_DEFINE_UNQUOTED(CMK_HAS_CXX11_ATOMIC, $pass, [whether C++ library has <atomic>])
1132
1133 if test $pass -ne 1
1134 then
1135 ### Check if we have pre-C++11 <cstdatomic> ###
1136 cat > $t <<EOT
1137 #include <cstdatomic>
1138 int main(int argc, char** argv) { 
1139   return 0;
1140 }
1141 EOT
1142 test_cxx "whether C++ library has <cstdatomic> " "yes" "no" ""
1143 AC_DEFINE_UNQUOTED(CMK_HAS_CXX0X_CSTDATOMIC, $pass, [whether C++ library has <cstdatomic>])
1144 fi
1145
1146 if test $pass -ne 1 -a "$CMK_COMPILER" != "bgxlc"
1147 then
1148         echo "Charm++ requires C++11 atomic support"
1149         test_finish 1
1150 fi
1151
1152 #### Check long double ####
1153 cat > $t <<EOT
1154 #include <stdlib.h>
1155 long double foo(void) { return 17.0; }
1156 EOT
1157 test_cxx "whether long double works" "yes" "no" ""
1158 AC_DEFINE_UNQUOTED(CMK_LONG_DOUBLE_DEFINED, $strictpass, [whether long double works])
1159
1160 #### Check ucontext and FPU pointer ####
1161 cat > $t <<EOT
1162 #include <ucontext.h>
1163 struct _libc_fpstate   fpstate;
1164 fpregset_t *fp;
1165 int main() {
1166   ucontext_t context;
1167   context.uc_mcontext.fpregs = 0;
1168 }
1169 EOT
1170 test_cxx "whether ucontext has FPU pointer" "yes" "no" ""
1171 AC_DEFINE_UNQUOTED(CMK_CONTEXT_FPU_POINTER, $pass, [whether ucontext has pointer])
1172
1173 if test $pass -eq 1
1174 then
1175 cat > $t <<EOT
1176 #include <ucontext.h>
1177
1178 int main()
1179 {
1180   ucontext_t context;
1181   context.uc_mcontext.uc_regs = 0;
1182 }
1183 EOT
1184 test_cxx "whether ucontext uses uc_regs" "yes" "no" ""
1185 AC_DEFINE_UNQUOTED(CMK_CONTEXT_FPU_POINTER_UCREGS, $pass, [whether ucontext uses uc_regs union])
1186 fi
1187
1188 cat > $t <<EOT
1189 #include <ucontext.h>
1190 vrregset_t *v_regs;
1191 ucontext_t  uc;
1192
1193 void foo()
1194 {
1195   vrregset_t *ptr = uc.uc_mcontext.v_regs;
1196 }
1197 EOT
1198 test_cxx "whether ucontext has pointer (v_regs) of vector type" "yes" "no" ""
1199 AC_DEFINE_UNQUOTED(CMK_CONTEXT_V_REGS, $pass, [whether ucontext has pointer (v_regs) of vector type])
1200
1201 #### Check ucontext and FPU pointer ####
1202 cat > $t <<EOT
1203 #include <infiniband/verbs.h>
1204 void test()
1205 {
1206     struct ibv_context    *context;
1207     int ibPort;
1208     struct ibv_port_attr attr;
1209     if (ibv_query_port(context, ibPort, &attr) != 0) return;
1210     if (attr.link_layer == IBV_LINK_LAYER_INFINIBAND)  return;
1211 }
1212 EOT
1213 test_cxx "whether ibverbs ibv_port_attr has link_layer field" "yes" "no" ""
1214 AC_DEFINE_UNQUOTED(CMK_IBV_PORT_ATTR_HAS_LINK_LAYER, $pass, [whether ibv_port_attr has link_layer field])
1215
1216
1217 ###################### C++ Compiler Features #####################
1218
1219 #### check C inline ####
1220 cat > $tc <<EOT
1221 inline static int foo()
1222 {
1223   return 1;
1224 }
1225 EOT
1226 test_cc "whether inline works in C" "yes" "no" ""
1227 AC_DEFINE_UNQUOTED(CMK_C_INLINE, $strictpass, [whether C inline works in C])
1228
1229 #### check if signed char is same as char ####
1230 cat > $t <<EOT
1231 #include <stdlib.h>
1232 class er {
1233  protected:
1234    void operator()(char &v,const char *desc=NULL) {};
1235    void operator()(signed char &v,const char *desc=NULL) {};
1236 };
1237 EOT
1238 test_cxx "whether C++ signed char and char differ" "yes" "no" ""
1239 AC_DEFINE_UNQUOTED(CMK_SIGNEDCHAR_DIFF_CHAR, $pass, [whether C++ signed char and char differ])
1240
1241 #### check if typeinfo exists and works #####
1242 cat > $t <<EOT
1243 #include <typeinfo>
1244 const char *foo(void) {
1245         int x;
1246         return typeid(x).name();
1247 }
1248 EOT
1249 test_cxx "whether typeinfo/typeid works" "ok" "no" ""
1250 AC_DEFINE_UNQUOTED(CMK_HAS_TYPEINFO, $pass, [whether typeinfo/typeid works])
1251
1252 #### check if iterator_traits is defined #####
1253 cat > $t <<EOT
1254 #include <iterator>
1255
1256 template <typename T> // T models Input Iterator
1257 typename std::iterator_traits<T>::value_type accumulate(T first, T last)
1258 {
1259       typename std::iterator_traits<T>::value_type result = 0;
1260       while(first != last)
1261             result += *first++;
1262       return result;
1263 }
1264 EOT
1265 test_cxx "whether std::iterator_traits is defined" "ok" "no" ""
1266 AC_DEFINE_UNQUOTED(CMK_HAS_ITERATOR_TRAITS, $pass, [whether iterator_traits works])
1267
1268 #### check if std::distance is defined #####
1269 cat > $t <<EOT
1270 #include <vector>
1271 #include <iterator>
1272
1273 int foo()
1274 {
1275   std::vector<int> tree;
1276   return std::distance(tree.begin(), tree.end());
1277 }
1278 EOT
1279 test_cxx "whether std::distance is defined" "ok" "no" ""
1280 AC_DEFINE_UNQUOTED(CMK_HAS_STD_DISTANCE, $pass, [whether std::distance works])
1281
1282 #### check if std::inserter is defined #####
1283 cat > $t <<EOT
1284 #include <list>
1285 #include <iterator>
1286
1287 void foo()
1288 {
1289   using namespace std;
1290   list<int> L;
1291   inserter ( L, L.end ( ) ) = 500;
1292 }
1293 EOT
1294 test_cxx "whether std::inserter is defined" "ok" "no" ""
1295 AC_DEFINE_UNQUOTED(CMK_HAS_STD_INSERTER, $pass, [whether std::inserter works])
1296
1297 #### check if C++17's std::void_t is defined #####
1298 cat > $t <<EOT
1299 #include <type_traits>
1300
1301 template<typename T, typename = std::void_t<>>
1302 struct has_pup_member : std::false_type {};
1303
1304 EOT
1305 test_cxx "whether std::void_t is defined" "ok" "no" ""
1306 AC_DEFINE_UNQUOTED(CMK_HAS_STD_VOID_T, $pass, [whether std::void_t works])
1307
1308 ####### Check support for features added by the new C11 and CPP11 standards ########
1309
1310 #### test if we can have multiple delete like this ####
1311 cat > $t <<EOT
1312 class foo {
1313 public:
1314   void operator delete(void*p){};
1315   void operator delete(void*p,int*){};
1316 };
1317 EOT
1318 test_cxx "whether operator delete can be overloaded in same class" "ok" "no" ""
1319 AC_DEFINE_UNQUOTED(CMK_MULTIPLE_DELETE, $strictpass, [whether operator delete can be overloaded in same class])
1320
1321 #### test if offsetof exists ####
1322 cat > $t <<EOT
1323 #include <stddef.h>
1324
1325 struct FooType {
1326         int f1;
1327         int f2;
1328         double f3;
1329 };
1330
1331 void foo()
1332 {
1333   int off = offsetof(FooType, f2);
1334 }
1335 EOT
1336 test_cxx "whether offsetof is defined" "yes" "no" ""
1337 AC_DEFINE_UNQUOTED(CMK_HAS_OFFSETOF, $pass, [whether offsetof exists])
1338
1339 #### test if we can use gcc x86 assembly like this ####
1340 cat > $t <<EOT
1341 double foo(void)
1342 {
1343   unsigned long long int v=0;
1344   int *lo=0+(int *)&v;
1345   int *hi=1+(int *)&v;
1346   __asm__ __volatile__(
1347       "rdtsc; movl %%edx,%0; movl %%eax,%1"
1348       : /* output  */ "=m" (*hi), "=m" (*lo)
1349       : /* input */
1350       : /* trashes */ "%edx", "%eax"
1351   );
1352   return v;
1353 }
1354 EOT
1355 test_cxx "whether GCC x86 assembly works" "yes" "no" ""
1356 AC_DEFINE_UNQUOTED(CMK_GCC_X86_ASM, $strictpass, [Allows gcc x86 assembly.])
1357
1358 #### test if we can use gcc x86 assembly like this ####
1359 if test $strictpass = 1
1360 then
1361 cat > $t <<EOT
1362 int foo(void)
1363 {
1364   int x;
1365   asm("lock incl %0" :: "m" (x));
1366   asm("lock decl %0" :: "m" (x));
1367   return x;
1368 }
1369 EOT
1370 test_cxx "whether GCC x86 assembly for atomic increment works" "yes" "no" ""
1371 AC_DEFINE_UNQUOTED(CMK_GCC_X86_ASM_ATOMICINCREMENT, $strictpass, [Allows gcc x86 assembly for atomic increment.])
1372 fi
1373
1374 #### test if we can use asm eieio assembly like this ####
1375 cat > $t <<EOT
1376 double foo(void)
1377 {
1378         unsigned long long int x;
1379         asm volatile("eieio" ::: "memory");
1380         return x;
1381 }
1382 EOT
1383 test_cxx "whether asm eieio assembly works" "yes" "no" ""
1384 AC_DEFINE_UNQUOTED(CMK_PPC_ASM, $strictpass, [Allows asm eieio assembly.])
1385
1386
1387
1388 #### test if we can use __thread ####
1389 cat > $t <<EOT
1390 __thread unsigned long long int x;
1391 static __thread  int y;
1392 void foo(void)
1393 {
1394         x = 1;
1395         y = 1;
1396 }
1397 EOT
1398 test_cxx "whether __thread (Thread Local Storage) is supported" "yes" "no" ""
1399 AC_DEFINE_UNQUOTED(CMK_HAS_TLS_VARIABLES, $strictpass, [Allows __thread.])
1400
1401 #### check __sync_add_and_fetch ####
1402 cat > $tc <<EOT
1403 #include <stdio.h>
1404 int main()
1405 {
1406   int t=1;
1407   __sync_add_and_fetch(&t, 1);
1408   return 1;
1409 }
1410 EOT
1411 test_linkc "whether synchronization primitives (__sync_add_and_fetch) works in C" "yes" "no" ""
1412 AC_DEFINE_UNQUOTED(CMK_C_SYNC_ADD_AND_FETCH_PRIMITIVE, $pass, [whether sync_add_and_fetch primitive works in C])
1413
1414 #### check __sync_synchronize ####
1415 cat > $tc <<EOT
1416 #include <stdio.h>
1417 int main()
1418 {
1419   __sync_synchronize();
1420 }
1421 EOT
1422
1423 test_linkc "whether synchronization primitives (__sync_synchronize) works in C" "yes" "no" ""
1424
1425 AC_DEFINE_UNQUOTED(CMK_C_SYNC_SYNCHRONIZE_PRIMITIVE, $pass, [whether sync_synchronize primitives works in C])
1426
1427
1428 ### test for __executable_start ###
1429
1430 cat > $tc <<EOT
1431 extern int __executable_start;
1432 int main()
1433 {
1434   return __executable_start;
1435 }
1436 EOT
1437 test_linkc "whether has __executable_start" "yes" "no" ""
1438 AC_DEFINE_UNQUOTED([CMK_HAS_EXECUTABLE_START], $pass, [whether has __executable_start])
1439
1440 ### test if switching TLS register ###
1441 if test $in64bit = 1
1442 then
1443 cat > $t <<EOT
1444 void switchTLS() {
1445   void * m1, * m2;
1446   asm volatile ("movq %%fs:0x0, %0\n\t"
1447                 "movq %1, %%fs:0x0\n\t"
1448                 : "=&r"(m1)
1449                 : "r"(m2));
1450 }
1451 EOT
1452 test_cxx "whether switching TLS register (64-bit) is supported" "yes" "no" ""
1453 AC_DEFINE_UNQUOTED(CMK_TLS_SWITCHING_X86_64, $strictpass, [Allows switching TLS on x86_64.])
1454 else
1455 cat > $t <<EOT
1456 void switchTLS() {
1457   void * m1, * m2;
1458   asm volatile ("movl %%gs:0x0, %0\n\t"
1459                 "movl %1, %%gs:0x0\n\t"
1460                 : "=&r"(m1)
1461                 : "r"(m2));
1462 }
1463 EOT
1464 test_cxx "whether switching TLS register (32-bit) is supported" "yes" "no" ""
1465 AC_DEFINE_UNQUOTED(CMK_TLS_SWITCHING_X86, $strictpass, [Allows switching TLS on x86.])
1466 fi
1467
1468 ### test for dl_iterate_phdr ###
1469
1470 cat > $tc <<EOT
1471 #ifndef _GNU_SOURCE
1472 # define _GNU_SOURCE
1473 #endif
1474 #ifndef __USE_GNU
1475 # define __USE_GNU
1476 #endif
1477 #include <link.h>
1478 #include <stddef.h>
1479 static int callback(struct dl_phdr_info* info, size_t size, void* data)
1480 {
1481   return 0;
1482 }
1483 int main()
1484 {
1485   dl_iterate_phdr(callback, NULL);
1486   return 0;
1487 }
1488 EOT
1489 test_linkc "whether has dl_iterate_phdr" "yes" "no" ""
1490 AC_DEFINE_UNQUOTED([CMK_HAS_DL_ITERATE_PHDR], $pass, [whether has dl_iterate_phdr])
1491
1492
1493 ### test for __malloc_hook ###
1494
1495 cat > $tc <<EOT
1496 extern int __malloc_hook;
1497 int main()
1498 {
1499   return __malloc_hook;
1500 }
1501 EOT
1502 test_linkc "whether has __malloc_hook" "yes" "no" ""
1503 AC_DEFINE_UNQUOTED([CMK_HAS_MALLOC_HOOK], $pass, [whether has __malloc_hook])
1504 add_make_flag "CMK_HAS_MALLOC_HOOK:=$pass" 'whether has __malloc_hook'
1505
1506
1507 #### test if we can build OFI ####
1508 if test "$CMK_BUILD_OFI" = 1
1509 then
1510 cat > $tc <<EOT
1511 #include <rdma/fabric.h>
1512 int main(int argc, char **argv)
1513 {
1514   struct fi_info *providers;
1515   int ret = fi_getinfo(FI_VERSION(1,0), NULL, NULL, 0ULL, NULL, &providers);
1516   return 0;
1517 }
1518 EOT
1519 test_cc "whether build on OFI" "yes" "no" "-lfabric"
1520 AC_DEFINE_UNQUOTED(CMK_BUILD_ON_OFI, $strictpass, [build OFI.])
1521 BUILD_OFI=$strictpass
1522
1523 if test $BUILD_OFI -eq 0
1524 then
1525   echo "Error: Unable to compile OFI"
1526   test_finish 1
1527 else
1528   test_linkc "whether -lfabric" "ok" "no" "-lfabric"
1529   if test $pass -eq 0
1530   then
1531     #test for psm incompatibility
1532     PSM_COMPAT_DIR=/usr/lib64/psm2-compat
1533     if test -d $PSM_COMPAT_DIR
1534     then
1535       add_flag CMK_LIBDIR='"$CMK_LIBDIR -Wl,-rpath=/usr/lib64/psm2-compat"' "psm2-compat lib"
1536       CMK_LIBDIR="$CMK_LIBDIR -Wl,-rpath=/usr/lib64/psm2-compat"
1537       test_linkc "whether -lfabric after adding psm2-compatible library" "ok" "no" "-lfabric"
1538       if test $pass -eq 0
1539       then
1540         echo "Error: -lfabric not found or not working. Pass '--basedir=/path/to/dir/' if -lfabric is located in a different directory"
1541         test_finish 1
1542       fi
1543     else
1544       echo "Error: -lfabric not working, $PSM_COMPAT_DIR not found"
1545       echo "Pass '--basedir=/path/to/dir/' if -lfabric is located in a different directory"
1546       test_finish 1
1547     fi
1548   fi
1549 fi
1550
1551 fi
1552
1553 #### test if we can build MPI ####
1554 if test "$CMK_BUILD_MPI" = 1
1555 then
1556
1557 cat > $tc <<EOT
1558 #include "mpi.h"
1559 int main(int argc, char **argv)
1560 {
1561   MPI_Init(&argc, &argv);
1562   return 0;
1563 }
1564 EOT
1565 mv -f ../include/mpi.h ../include/mpi.h.bak 2>/dev/null
1566 test_cc "whether build on MPI" "yes" "no" ""
1567 AC_DEFINE_UNQUOTED(CMK_BUILD_ON_MPI, $strictpass, [build MPI.])
1568 BUILD_MPI=$strictpass
1569
1570 if test $BUILD_MPI -eq 0
1571 then
1572   echo "Error: Cannot compile an MPI program"
1573   test_finish 1
1574 fi
1575
1576 if test $BUILD_MPI -eq 1
1577 then
1578   test_linkc "whether need to specify MPI library" "no" "yes" ""
1579   if test $pass -ne 1
1580   then
1581     if test -z "$CMK_MPI_LIB"
1582     then
1583       test_linkc "whether -lmpich" "ok" "no" "-lmpich"
1584       if test $pass -eq 1
1585       then
1586         add_flag CMK_SYSLIBS='"$CMK_SYSLIBS -lmpich"' "mpi lib"
1587       else
1588         test_linkc "whether -lmpi" "ok" "no" "-lmpi"
1589         if test $pass -eq 1
1590         then
1591                 add_flag CMK_SYSLIBS='"$CMK_SYSLIBS -lmpi"' "mpi lib"
1592         else
1593                 echo "Error: Cannot find MPI library"
1594                 test_finish 1
1595         fi
1596       fi
1597     else
1598       add_flag CMK_SYSLIBS='"$CMK_SYSLIBS $CMK_MPI_LIB"' "mpi lib"
1599     fi
1600   fi
1601 fi
1602
1603 if test "$BUILD_MPI" = "1"
1604 then
1605 cat > $t <<EOT
1606 #include "mpi.h"
1607 int main(int argc, char **argv)
1608 {
1609   int thread_level, provided;
1610   thread_level = MPI_THREAD_FUNNELED;
1611   MPI_Init_thread(&argc, &argv, thread_level, &provided);
1612 }
1613 EOT
1614 test_cxx "whether MPI_Init_thread is supported" "yes" "no" ""
1615 AC_DEFINE_UNQUOTED(CMK_MPI_INIT_THREAD, $strictpass, [Allows MPI_Init_thread.])
1616 fi
1617 mv -f ../include/mpi.h.bak ../include/mpi.h 2>/dev/null
1618
1619 fi
1620
1621 if test "$BUILD_MPI" = "1"
1622 then
1623
1624 cat > $t <<EOT
1625 #include <stdio.h>
1626 #include <mpi.h>
1627
1628 int main (int argc, char** argv) {
1629   return 0;
1630 }
1631 EOT
1632 test_cxx "whether macro conflicts occurs due to C++ MPI bindings" "no" "yes" ""
1633 AC_DEFINE_UNQUOTED(CMK_CXX_MPI_BINDINGS, $strictpass, [Disables conflicting macros.])
1634 fi
1635
1636
1637 ################### Syscalls and Libraries ###################
1638
1639 #### test for getrusage with RUSAGE_THREAD ###
1640 cat > $tc <<EOT
1641 #ifndef _GNU_SOURCE
1642 # define _GNU_SOURCE
1643 #endif
1644 #ifndef __USE_GNU
1645 # define __USE_GNU
1646 #endif
1647 #include <sys/time.h>
1648 #include <sys/resource.h>
1649 int main() {
1650   struct rusage usage;
1651   getrusage(RUSAGE_THREAD, &usage);
1652   return 0;
1653 }
1654 EOT
1655 test_linkc "whether getrusage accepts RUSAGE_THREAD" "yes" "no" ""
1656 AC_DEFINE_UNQUOTED(CMK_HAS_RUSAGE_THREAD, $pass, [whether getrusage accepts RUSAGE_THREAD])
1657
1658 #### test for asctime ###
1659
1660 cat > $tc <<EOT
1661 #include <time.h>
1662 int main() {
1663   struct tm *local;
1664   time_t t;
1665   t = time(NULL);
1666   local = localtime(&t);
1667   asctime(local);
1668   return 0;
1669 }
1670 EOT
1671 test_linkc "whether has asctime" "yes" "no" ""
1672 AC_DEFINE_UNQUOTED(CMK_HAS_ASCTIME, $pass, [whether has asctime])
1673
1674 #### test for log2 ###
1675 cat > $t <<EOT
1676 #include <math.h>
1677 int main() {
1678   int i = log2(10);
1679   return 0;
1680 }
1681 EOT
1682 test_link "whether has log2" "yes" "no" ""
1683 AC_DEFINE_UNQUOTED(CMK_HAS_LOG2, $pass, [whether has log2])
1684
1685 #### test for sqrtf ###
1686 cat > $t <<EOT
1687 #include <math.h>
1688 int main() {
1689   float i = sqrtf((float)10.0);
1690   return 0;
1691 }
1692 EOT
1693 test_link "whether has sqrtf" "yes" "no" ""
1694 AC_DEFINE_UNQUOTED(CMK_HAS_SQRTF, $pass, [whether has sqrtf])
1695
1696 #### test for fabsf ###
1697 cat > $t <<EOT
1698 #include <math.h>
1699 int main() {
1700   float i = fabsf((float)10.0);
1701   return 0;
1702 }
1703 EOT
1704 test_link "whether has fabsf" "yes" "no" ""
1705 AC_DEFINE_UNQUOTED(CMK_HAS_FABSF, $pass, [whether has fabsf])
1706
1707 #### test for mkstemp ###
1708 cat > $t <<EOT
1709 #include <stdlib.h>
1710 #include <string.h>
1711 int main() {
1712   char fname[[128]];
1713   strcpy(fname, "/tmp/fdXXX.XXX");
1714   mkstemp(fname);
1715   return 0;
1716 }
1717 EOT
1718 test_link "whether has mkstemp" "yes" "no" ""
1719 AC_DEFINE_UNQUOTED(CMK_USE_MKSTEMP, $pass, [whether has mkstemp])
1720
1721 #### test for system ###
1722 cat > $t <<EOT
1723 #include <stdlib.h>
1724 int main() {
1725   system("/bin/ls");
1726   return 0;
1727 }
1728 EOT
1729 test_link "whether has system" "yes" "no" ""
1730 AC_DEFINE_UNQUOTED(CMK_HAS_SYSTEM, $pass, [whether has system])
1731
1732 #### test for sync() ###
1733 cat > $t <<EOT
1734 #include <unistd.h>
1735 int main() {
1736   sync();
1737   return 0;
1738 }
1739 EOT
1740 test_link "whether has sync()" "yes" "no" ""
1741 AC_DEFINE_UNQUOTED(CMK_HAS_SYNC_FUNC, $pass, [whether has sync])
1742
1743 #### test for fsync() ###
1744 cat > $t <<EOT
1745 #include <unistd.h>
1746 int main() {
1747   fsync(0);
1748   return 0;
1749 }
1750 EOT
1751 test_link "whether has fsync()" "yes" "no" ""
1752 AC_DEFINE_UNQUOTED(CMK_HAS_FSYNC_FUNC, $pass, [whether has fsync])
1753
1754 #### test for fdatasync() ###
1755 cat > $t <<EOT
1756 #include <unistd.h>
1757 int main() {
1758   fdatasync(0);
1759   return 0;
1760 }
1761 EOT
1762 test_link "whether has fdatasync()" "yes" "no" ""
1763 AC_DEFINE_UNQUOTED(CMK_HAS_FDATASYNC_FUNC, $pass, [whether has fdatasync])
1764
1765 #### test for sbrk ###
1766 cat > $t <<EOT
1767 #include <unistd.h>
1768 int main() {
1769   void *ptr  = sbrk(0); 
1770 }
1771 EOT
1772 test_link "whether has sbrk" "yes" "no" ""
1773 AC_DEFINE_UNQUOTED(CMK_HAS_SBRK, $pass, [whether has sbrk])
1774
1775 #### test for _setjmp/_longjmp ###
1776 cat > $t <<EOT
1777 #include <setjmp.h>
1778 int main() {
1779   jmp_buf buf;
1780   _setjmp(buf);
1781   _longjmp(buf, 0);
1782 }
1783 EOT
1784 test_link "whether has _setjmp/_longjmp" "yes" "no" ""
1785 AC_DEFINE_UNQUOTED(CMK_HAS_UNDERSCORE_SETJMP, $pass, [whether has _setjmp/_longjmp])
1786
1787 #### test for mstats ###
1788 cat > $t <<EOT
1789 #include <malloc.h>
1790 int main() {
1791   struct mstats ms = mstats();
1792 }
1793 EOT
1794 test_link "whether has mstats" "yes" "no" ""
1795 AC_DEFINE_UNQUOTED(CMK_HAS_MSTATS, $pass, [whether has mstats])
1796
1797 #### test for mallinfo ###
1798 cat > $t <<EOT
1799 #include <malloc.h>
1800 int main() {
1801   struct mallinfo mi = mallinfo();
1802 }
1803 EOT
1804 test_link "whether has mallinfo" "yes" "no" ""
1805 AC_DEFINE_UNQUOTED(CMK_HAS_MALLINFO, $pass, [whether has mallinfo])
1806
1807 #### test for __morecore ###
1808 cat > $t <<EOT
1809 #include <cstddef>
1810 int main() {
1811   extern void *(*__morecore)(ptrdiff_t);
1812   __morecore(0);
1813   return 0;
1814 }
1815 EOT
1816 test_link "whether expects __morecore symbol" "yes" "no" ""
1817 AC_DEFINE_UNQUOTED(CMK_EXPECTS_MORECORE, $pass, [whether expects __morecore symbol])
1818
1819 #### test for popen ###
1820 cat > $t <<EOT
1821 #include <stdio.h>
1822 int main() {
1823   FILE *p = popen("/bin/ps", "r");
1824   pclose(p);
1825 }
1826 EOT
1827 test_link "whether has popen" "yes" "no" ""
1828 AC_DEFINE_UNQUOTED(CMK_HAS_POPEN, $pass, [whether has popen])
1829
1830 #### test for poll ###
1831 cat > $t <<EOT
1832 #include <poll.h>
1833 void foo(void) { 
1834   struct pollfd pos[[3]];
1835   poll(pos, 1, 1);
1836 }
1837 EOT
1838 test_cxx "whether has poll" "yes" "no" ""
1839 AC_DEFINE_UNQUOTED(CMK_USE_POLL, $pass, [whether the poll syscall exists])
1840
1841 #### check if getpagesize exists ####
1842 cat > $tc <<EOT
1843 #include <unistd.h>
1844
1845 int main(int argc, char **argv) {
1846     int s = getpagesize();
1847 }
1848 EOT
1849 test_linkc "whether has getpagesize" "yes" "no" ""
1850 AC_DEFINE_UNQUOTED(CMK_HAS_GETPAGESIZE, $pass, [whether getpagesize exists])
1851
1852 #### check if getpid exists ####
1853 cat > $tc <<EOT
1854 #include <sys/types.h>
1855 #include <unistd.h>
1856
1857 int main(int argc, char **argv) {
1858     pid_t pid = getpid();
1859 }
1860 EOT
1861 test_linkc "whether has getpid" "yes" "no" ""
1862 AC_DEFINE_UNQUOTED(CMK_HAS_GETPID, $pass, [whether getpid exists])
1863
1864 #### check if kill exists ####
1865 cat > $tc <<EOT
1866 #include <sys/types.h>
1867 #include <unistd.h>
1868 #include <signal.h>
1869
1870 int main(int argc, char**argv) 
1871 {
1872     pid_t pid = getpid();
1873     kill(pid, 9);
1874 }
1875 EOT
1876 test_linkc "whether has kill" "yes" "no" ""
1877 AC_DEFINE_UNQUOTED(CMK_HAS_KILL, $pass, [whether kill exists])
1878
1879 #### test for setpriority ###
1880 cat > $t <<EOT
1881 #include <sys/time.h>
1882 #include <sys/resource.h>
1883 void foo(void) { 
1884   setpriority(PRIO_PROCESS, 0, 0);
1885 }
1886 EOT
1887 test_cxx "whether has setpriority" "yes" "no" ""
1888 AC_DEFINE_UNQUOTED(CMK_HAS_SETPRIORITY, $pass, [whether the setpriority exists])
1889
1890 #### test for system ###
1891 cat > $t <<EOT
1892 #include "ckdll_system.C"
1893 EOT
1894 test_cxx "whether to use signal-safe system() " "yes" "no" ""
1895 AC_DEFINE_UNQUOTED(CMK_SIGSAFE_SYSTEM, $pass, [whether to use signal-safe system()])
1896
1897 ### test sched_setaffinity ####
1898 cat > $tc <<EOT
1899 #define _GNU_SOURCE
1900 #include <sched.h>
1901
1902 int main()
1903 {
1904   cpu_set_t cpuset;
1905   CPU_ZERO(&cpuset);
1906   CPU_SET(0, &cpuset);
1907   if (sched_setaffinity(0, sizeof(cpuset), &cpuset) < 0) {
1908     return -1;
1909   }
1910   return 0;
1911 }
1912 EOT
1913 test_linkc "whether sched_setaffinity call exists" "yes" "no" ""
1914 AC_DEFINE_UNQUOTED(CMK_HAS_SETAFFINITY, $pass, [whether the sched_setaffinity() exists])
1915
1916 ### test pthread_setaffinity_np ####
1917 cat > $tc <<EOT
1918 #include <stdlib.h>
1919 #include <stdio.h>
1920 #include <unistd.h>
1921 #include <pthread.h>
1922
1923 int main()
1924 {
1925   unsigned long mask = 0xffffffff;
1926   unsigned int len = sizeof(mask);
1927
1928   if (pthread_setaffinity_np(pthread_self(), len, &mask) < 0) {
1929     return -1;
1930   }
1931   return 0;
1932 }
1933 EOT
1934 test_linkc "whether pthread_setaffinity_np call exists" "yes" "no" "-lpthread"
1935 AC_DEFINE_UNQUOTED(CMK_HAS_PTHREAD_SETAFFINITY, $pass, [whether the pthread_setaffinity_np() exists])
1936
1937 ### test pthread_spin_lock ####
1938 cat > $tc <<EOT
1939 #include <stdlib.h>
1940 #include <stdio.h>
1941 #include <unistd.h>
1942 #include <pthread.h>
1943
1944 int main()
1945 {
1946   pthread_spinlock_t  lock;
1947
1948   pthread_spin_init(&lock, 0);
1949
1950   pthread_spin_lock(&lock);
1951
1952   return 0;
1953 }
1954 EOT
1955 test_linkc "whether pthread_spin_lock exists" "yes" "no" "-lpthread"
1956 AC_DEFINE_UNQUOTED(CMK_HAS_SPINLOCK, $pass, [whether the pthread_spin_lock exists])
1957
1958 ### check libnuma on Linux ####
1959 if test "$WITH_NUMA" = "yes"
1960 then
1961 cat > $tc <<EOT
1962 #include <stdlib.h>
1963 #include <stdio.h>
1964 #include <linux/mempolicy.h>
1965 #include <numaif.h>
1966 #include <numa.h>
1967
1968 int main()
1969 {
1970   if (get_mempolicy(NULL, NULL, 0, 0, 0) == 0) return 0;
1971   return -1;
1972 }
1973 EOT
1974 test_linkc "whether libnuma exists" "yes" "no" "-lnuma"
1975 AC_DEFINE_UNQUOTED(CMK_HAS_NUMACTRL, $pass, [whether NUMA control related functions exist])
1976 if test $pass -eq 1
1977 then
1978         add_flag 'CMK_SYSLIBS="$CMK_SYSLIBS -lnuma"' "libnuma"
1979 fi
1980 fi
1981
1982 #### check bindprocessors on AIX ####
1983 cat > $tc <<EOT
1984 #include <stdlib.h>
1985 #include <stdio.h>
1986 #include <unistd.h>
1987
1988 #include <sys/processor.h>
1989
1990 int main()
1991 {
1992   int retValue = 0;
1993   int pid;
1994   pid = getpid();
1995   if (bindprocessor(BINDPROCESS, pid, 0) == -1) return -1;
1996   return 0;
1997 }
1998 EOT
1999 test_linkc "whether bindprocessor call exists" "yes" "no" ""
2000 AC_DEFINE_UNQUOTED(CMK_HAS_BINDPROCESSOR, $pass, [whether the bindprocessor()
2001 exists])
2002
2003
2004 #### check if dlopen works ####
2005 skip_dl=0
2006 # for bproc, ignore -ldl
2007 test -n "$CMK_BPROC" && skip_dl=1
2008 test -n "$CMK_NO_DL" && skip_dl=1
2009 dl_opt='-ldl'
2010 #workaround for pgcc 4.0, -ldl crash linking, so use -Wl,-ldl to skip the prelinker.
2011 case "$CMK_CXX" in
2012 pgCC*) dl_opt='-Wl,-ldl' ;;
2013 esac
2014
2015 if test $skip_dl -eq 0 
2016 then
2017
2018 cat > $t <<EOT
2019 #include "ckdll_dlopen.C"
2020 int main() {
2021         CkDll dll("foo.so");
2022         return 0;
2023 }
2024 EOT
2025 test_link "whether dlopen links without $dl_opt" "yes" "no" ""
2026 noldl=$pass
2027 test_link "whether dlopen links with $dl_opt" "yes" "no" "$dl_opt"
2028 if test $pass -eq 1
2029 then 
2030 #dlopen requires -ldl: add it to our link line
2031         add_flag CMK_LIBS='"$CMK_LIBS '$dl_opt'"' "dlopen"
2032 fi
2033
2034 if test $pass -eq 1 -o $noldl -eq 1
2035 then
2036 # One version or another of dlopen worked: compile it in
2037         AC_DEFINE_UNQUOTED(CMK_DLL_USE_DLOPEN, 1, [dlopen])
2038 fi
2039
2040 cat > $tc <<EOT
2041 #ifndef _GNU_SOURCE
2042 # define _GNU_SOURCE
2043 #endif
2044 #ifndef __USE_GNU
2045 # define __USE_GNU
2046 #endif
2047 #include <dlfcn.h>
2048 #include <stddef.h>
2049 int main()
2050 {
2051   return dlsym(RTLD_DEFAULT, "main") != NULL;
2052 }
2053 EOT
2054 test_cc "whether has RTLD_DEFAULT" "yes" "no" ""
2055 AC_DEFINE_UNQUOTED(CMK_HAS_RTLD_DEFAULT, $pass, [whether has RTLD_DEFAULT])
2056
2057 cat > $tc <<EOT
2058 #ifndef _GNU_SOURCE
2059 # define _GNU_SOURCE
2060 #endif
2061 #ifndef __USE_GNU
2062 # define __USE_GNU
2063 #endif
2064 #include <dlfcn.h>
2065 #include <stddef.h>
2066 int main()
2067 {
2068   return dlsym(RTLD_NEXT, "main") != NULL;
2069 }
2070 EOT
2071 test_cc "whether has RTLD_NEXT" "yes" "no" ""
2072 AC_DEFINE_UNQUOTED(CMK_HAS_RTLD_NEXT, $pass, [whether has RTLD_NEXT])
2073
2074 ### test gethostname ####
2075 cat > $tc <<EOT
2076 #ifdef _WIN32
2077 #include <Winsock2.h>
2078 #else
2079 #include <stdlib.h>
2080 #include <stdio.h>
2081 #include <unistd.h>
2082 #endif
2083
2084 int main()
2085 {
2086   char hostname[[1000]];
2087   gethostname(hostname, 999);
2088   return 0;
2089 }
2090 EOT
2091 test_cc "whether gethostname call exists" "yes" "no" ""
2092 AC_DEFINE_UNQUOTED(CMK_HAS_GETHOSTNAME, $pass, [whether gethostname() exists])
2093
2094 #### check if getProcAddress works ####
2095 cat > $t <<EOT
2096 #include "ckdll_win32.C"
2097 EOT
2098 test_cxx "whether getProcAddress works" "yes" "no" ""
2099 AC_DEFINE_UNQUOTED(CMK_DLL_USE_WIN32, $pass, [whether getProcAddress works])
2100
2101 fi    # end of skip_dl
2102
2103 #### check if socklen_t exists ####
2104 cat > $t <<EOT
2105 #include <sys/types.h>
2106 #include <sys/socket.h>
2107
2108 void foo(void) {
2109         int i;
2110         socklen_t s=sizeof(i);
2111 }
2112 EOT
2113 test_cxx "whether has socklen_t" "yes" "no" ""
2114 AC_DEFINE_UNQUOTED(CMK_HAS_SOCKLEN, $pass, [whether has socklen_t])
2115
2116 ### test getifaddrs ####
2117 cat > $tc <<EOT
2118 #include <netinet/in.h> /* for sockaddr_in */
2119 #include <ifaddrs.h> /* for getifaddrs */
2120 #include <net/if.h> /* for IFF_RUNNING */
2121
2122 int main()
2123 {
2124   struct ifaddrs *interfaces=0;
2125   if( getifaddrs(&interfaces) == 0 ) {
2126         struct ifaddrs *interface;
2127         for( interface=interfaces; interface; interface=interface->ifa_next ) {
2128             if( (interface->ifa_flags & IFF_UP) && ! (interface->ifa_flags & IFF_LOOPBACK) ) {
2129                 const struct sockaddr_in *addr = (const struct sockaddr_in*)interface->ifa_addr;
2130                 if( addr && addr->sin_family==AF_INET ) {
2131                     break;
2132                 }
2133             }
2134         }
2135         freeifaddrs(interfaces);
2136   }
2137 }
2138 EOT
2139 test_linkc "whether getifaddrs call exists" "yes" "no" ""
2140 AC_DEFINE_UNQUOTED(CMK_HAS_GETIFADDRS, $pass, [whether getifaddrs() exists])
2141
2142 #### check if mmap exists ####
2143 cat > $t <<EOT
2144 #include <sys/types.h>
2145 #include <sys/mman.h>
2146
2147 void *foo(void *a,int l,int fd) {
2148         return mmap((caddr_t)a,l,PROT_READ+PROT_WRITE,
2149                  MAP_FIXED+MAP_PRIVATE,fd,0);
2150 }
2151 EOT
2152 test_cxx "whether the mmap() syscall exists" "yes" "no" ""
2153 AC_DEFINE_UNQUOTED(CMK_HAS_MMAP, $pass, [whether the mmap() syscall exists])
2154 add_flag "CMK_HAS_MMAP=$pass"
2155 add_make_flag "CMK_HAS_MMAP:=$pass"
2156
2157 #### check if mmap accepts MAP_ANON ####
2158 cat > $t <<EOT
2159 #include <sys/types.h>
2160 #include <sys/mman.h>
2161
2162 void *foo(void *a,int l) {
2163         return mmap((caddr_t)a,l,PROT_READ+PROT_WRITE,
2164                 MAP_FIXED+MAP_PRIVATE+MAP_ANON,-1,0);
2165 }
2166 EOT
2167 test_cxx "whether mmap() accepts MAP_ANON" "yes" "no" ""
2168 AC_DEFINE_UNQUOTED(CMK_HAS_MMAP_ANON, $pass, [whether mmap() accepts MAP_ANON])
2169
2170 #### check if mmap accepts MAP_NORESERVE ####
2171 cat > $t <<EOT
2172 #include <sys/types.h>
2173 #include <sys/mman.h>
2174
2175 void *foo(void *a,int l) {
2176         return mmap((caddr_t)a,l,PROT_READ+PROT_WRITE,
2177                 MAP_FIXED+MAP_PRIVATE+MAP_NORESERVE,-1,0);
2178 }
2179 EOT
2180 test_cxx "whether mmap() accepts MAP_NORESERVE" "yes" "no" ""
2181 AC_DEFINE_UNQUOTED(CMK_HAS_MMAP_NORESERVE, $pass, [whether mmap() accepts MAP_NORESERVE])
2182
2183 #### check if get_myaddress exists ####
2184 cat > $t <<EOT
2185 #include <rpc/rpc.h>
2186
2187 void foo(void *a) {
2188     get_myaddress((struct sockaddr_in*)a);
2189 }
2190 EOT
2191 test_cxx "whether has get_myaddress" "yes" "no" ""
2192 AC_DEFINE_UNQUOTED(CMK_HAS_GET_MYADDRESS, $pass, [whether has get_myaddress])
2193
2194 #### check if mprotect exists ####
2195 cat > $t <<EOT
2196 #include <stdio.h>
2197 #include <sys/mman.h>
2198
2199 void foo(void *a,int l,int fd) {
2200      void *pg = NULL;
2201      size_t pagesize = 4096;
2202      mprotect(pg, pagesize, PROT_READ | PROT_WRITE);
2203 }
2204 EOT
2205 test_cxx "whether has mprotect" "yes" "no" ""
2206 AC_DEFINE_UNQUOTED(CMK_HAS_MPROTECT, $pass, [whether has mprotect])
2207
2208 #### check if support for SHM through CMA exists ####
2209 cat > $t <<EOT
2210 #define _GNU_SOURCE
2211 #include <sys/uio.h>
2212 #include <errno.h>
2213 int main() {
2214   pid_t pid;
2215   struct iovec *local, *remote;
2216   int nread = process_vm_readv(pid, local, 1, remote, 1, 0);
2217   nread = process_vm_writev(pid, local, 1, remote, 1, 0);
2218   return errno;
2219 }
2220 EOT
2221 test_link "whether has support for shm transport using Cross Memory Attach" "yes" "no" ""
2222 AC_DEFINE_UNQUOTED(CMK_HAS_CMA, $pass, [whether supports cma])
2223
2224 #### check if -rdynamic works ####
2225 cat > $t <<EOT
2226 int main() {
2227   return 0;
2228 }
2229 EOT
2230 TRACE_LINK_FLAG=''
2231 CAN_EXPORT_SYMBOLS='0'
2232 for i in '-rdynamic' '-Wl,--export-dynamic'; do
2233   test_link "whether has $i" "yes" "no" "$i"
2234   if test "$strictpass" = '1'; then
2235     TRACE_LINK_FLAG="$i"
2236     CAN_EXPORT_SYMBOLS='1'
2237     break
2238   fi
2239 done
2240
2241 if test "$CAN_EXPORT_SYMBOLS" = '1'; then
2242   add_flag 'CMK_LD="$CMK_LD '$TRACE_LINK_FLAG'"' "exporting program symbols to shared objects"
2243   add_flag 'CMK_LDXX="$CMK_LDXX '$TRACE_LINK_FLAG'"' "exporting program symbols to shared objects"
2244 fi
2245
2246 #### check if glibc backtrace exists ####
2247 cat > $t <<EOT
2248 #include "cmibacktrace.c"
2249
2250 int main() {
2251         int nLevels=1;
2252         void *stack;
2253         CmiBacktraceRecord(&stack,0,&nLevels);
2254         return 0;
2255 }
2256 EOT
2257 test_link "whether glibc backtrace works" "yes" "no" "-DCMK_USE_BACKTRACE=1 $TRACE_LINK_FLAG"
2258 AC_DEFINE_UNQUOTED(CMK_USE_BACKTRACE, $pass, [whether glibc backtrace works])
2259
2260 #### test sleep ####
2261 cat > $t <<EOT
2262 #include <unistd.h>
2263 int main() {
2264   sleep(1);
2265   return 0;
2266 }
2267 EOT
2268 test_cxx "whether has sleep " "yes" "no" ""
2269 AC_DEFINE_UNQUOTED(CMK_HAS_SLEEP, $pass, [whether has sleep])
2270
2271 #### test usleep ####
2272 cat > $t <<EOT
2273 #include <unistd.h>
2274 int main() {
2275   usleep(100);
2276   return 0;
2277 }
2278 EOT
2279 test_cxx "whether has usleep " "yes" "no" ""
2280 AC_DEFINE_UNQUOTED(CMK_HAS_USLEEP, $pass, [whether has usleep])
2281
2282 #### test personality() and ADDR_NO_RANDOMIZE ####
2283 # Only works on modern Linux systems
2284 cat > $t <<EOT
2285 #include <sys/personality.h>
2286 int main() {
2287     int orig_persona = personality(0xffffffff);
2288     personality(orig_persona | ADDR_NO_RANDOMIZE);
2289     return 0;
2290 }
2291 EOT
2292 test_cxx "whether personality() and ADDR_NO_RANDOMIZE exist" "yes" "no" ""
2293 AC_DEFINE_UNQUOTED(CMK_HAS_ADDR_NO_RANDOMIZE, $pass, [whether personality() and ADDR_NO_RANDOMIZE exist])
2294
2295
2296 # enable/disable zlib
2297 AC_ARG_ENABLE([zlib],
2298             [AS_HELP_STRING([--enable-zlib],
2299               [enable zlib support])],
2300             [enable_zlib=$enableval],
2301             [enable_zlib=yes])
2302
2303 #### test if has zlib ####
2304 # bproc doesnot like -lz in any case
2305 if test -z "$CMK_BPROC" && test "$enable_zlib" = "yes"
2306 then
2307
2308 cat > $t <<EOT
2309 #include <zlib.h>
2310 int main() { 
2311   gzFile f = gzopen("/tmp/x","r");
2312   gzprintf(f, "test...\n");
2313   gzclose(f);
2314   return 0;
2315 }
2316 EOT
2317 test_link "whether has zlib" "yes" "no" "-lz"
2318 AC_DEFINE_UNQUOTED(CMK_USE_ZLIB, $pass, [whether has zlib])
2319 if test $pass -eq 1
2320 then 
2321         add_flag 'CMK_SYSLIBS="$CMK_SYSLIBS -lz"' "zlib"
2322 fi
2323
2324 fi
2325
2326 #### test if has elf.h ####
2327 cat > $t <<EOT
2328 #include <elf.h>
2329 typedef Elf32_Addr ELF_TYPE_Addr;
2330 int main() { 
2331 }
2332 EOT
2333 test_cxx "whether has elf.h " "yes" "no" ""
2334 AC_DEFINE_UNQUOTED([CMK_HAS_ELF_H], $pass, [whether has elf.h])
2335 if test $pass -eq 1
2336 then
2337         add_flag "CMK_HAS_ELF_H='1'" "elf.h"
2338 fi
2339
2340 #### test if has Multiprocessing.h for apple ####
2341 cat > $t <<EOT
2342 #include <Carbon/Carbon.h>
2343 #include <Multiprocessing.h>
2344 int main() {
2345   int a = MPProcessorsScheduled();
2346 }
2347 EOT
2348 test_cxx "whether has Multiprocessing.h for Apple " "yes" "no" ""
2349 AC_DEFINE_UNQUOTED([CMK_HAS_MULTIPROCESSING_H], $pass, [whether has Multiprocessing.h])
2350
2351 #### test if "ntohl" is available ####
2352 cat > $t <<EOT
2353 #if defined(_WIN32) || defined(__MINGW_H)
2354 #include <winsock.h>
2355 #else
2356 #include <stdint.h>
2357 #include <arpa/inet.h>
2358 #include <netinet/in.h>
2359 #endif
2360
2361 int main() {
2362   int i = 100;
2363   i = ntohl(i);
2364   return 0;
2365 }
2366 EOT
2367 test_cc "whether ntohl is available" "yes" "no" ""
2368 AC_DEFINE_UNQUOTED(CMK_HAS_NTOHL, $pass, [whether ntohl is available])
2369
2370 ### test for libjpeg ####
2371 cat > $t <<EOT
2372 #include <stdio.h>
2373 #include <stdlib.h>
2374 #include "jpeglib.h"
2375
2376 int main()
2377 {
2378   struct jpeg_compress_struct cinfo;
2379   jpeg_create_compress(&cinfo);
2380   return 0;
2381 }
2382 EOT
2383 test_link "whether has libjpeg" "yes" "no" "-ljpeg"
2384 AC_DEFINE_UNQUOTED(CMK_USE_LIBJPEG, $pass, [whether has libjpeg])
2385 if test $pass -eq 1
2386 then
2387         add_flag 'CMK_LIBJPEG="-ljpeg"' "libjpeg"
2388         add_make_flag 'CMK_LIBJPEG:=-ljpeg' 'libjpeg'
2389 fi
2390
2391 #### check if PAPI exists ####
2392 if test -n "$CMK_USE_PAPI"
2393 then
2394 cat > $t <<EOT
2395 #include <stdio.h>
2396 #include <papi.h>
2397                                                                                 
2398 int main() {
2399     if (PAPI_library_init(PAPI_VER_CURRENT) != PAPI_VER_CURRENT) return 1;
2400     return 0;
2401 }
2402 EOT
2403 test_link "whether PAPI exists" "yes" "no" "-lpapi"
2404 AC_DEFINE_UNQUOTED(CMK_HAS_COUNTER_PAPI, $pass, [whether PAPI exists])
2405 if test "$enable_tracing" = "no"
2406 then
2407         echo "Error: Cannot build papi version when tracing is disabled, build with --enable-tracing"
2408         test_finish 1
2409 elif test $fail -eq 1
2410 then
2411         echo "Error: Cannot find papi library"
2412         test_finish 1
2413 else
2414         add_flag 'CMK_LIBS="$CMK_LIBS -lpapi"' "papi"
2415 fi
2416 fi
2417
2418 #### test if Python headers are installed ####
2419 PYTHON_VERSION=`python -V 2>&1 | awk {'print $2'} | awk -F. {'print $1"."$2'}`
2420 cat > $t <<EOT
2421 #include "python${PYTHON_VERSION}/Python.h"
2422 #include "python${PYTHON_VERSION}/compile.h"
2423 #include "python${PYTHON_VERSION}/eval.h"
2424 #include "python${PYTHON_VERSION}/node.h"
2425
2426 int main() {
2427     Py_Initialize();
2428     PyEval_InitThreads();
2429     struct _node* programNode = PyParser_SimpleParseString("return 1\n",Py_file_input);
2430     PyCodeObject *program = PyNode_Compile(programNode, "");
2431 }
2432 EOT
2433 test_link "whether Python is installed" "yes" "no" "-lpython$PYTHON_VERSION -lpthread -lutil -ldl"
2434 AC_DEFINE_UNQUOTED(CMK_HAS_PYTHON, $pass, [whether Python is installed])
2435 AC_DEFINE_UNQUOTED(CMK_PYTHON_VERSION, ${PYTHON_VERSION}, [Python version])
2436 if test $pass -eq 1
2437 then
2438         add_flag "CMK_BUILD_PYTHON=$PYTHON_VERSION" "python"
2439         add_make_flag "CMK_BUILD_PYTHON:=$PYTHON_VERSION" 'python'
2440 fi
2441
2442 ## Cray specific test
2443 if test "$CMK_BUILD_CRAY" = "1"
2444 then
2445 #echo "Test for known incompatible compiler versions"
2446
2447  if test "$CRAY_CC_VERSION" = "8.1.4"
2448  then
2449         echo "CCE 8.1.4 produces incorrect Charm++ code"
2450         echo "Please use a newer version of the CCE compiler"
2451         echo "e.g. module load cce/8.1.7"
2452         test_finish 1
2453  fi
2454
2455 #### test if Cray node topology will work ####
2456 cat > $tc <<EOT
2457 #include <pmi.h>
2458
2459 int main() {
2460     int nid;
2461     PMI_Get_nid(0, &nid);
2462
2463     return 0;
2464 }
2465 EOT
2466 test_linkc "whether PMI_Get_nid exists" "yes" "no" "$CMK_CRAY_LIBS"
2467 AC_DEFINE_UNQUOTED(CMK_HAS_PMI_GET_NID, $pass, [whether PMI_Get_nid exists])
2468
2469 #### test if Cray mesh topology will work ####
2470 cat > $tc <<EOT
2471 #include <rca_lib.h>
2472
2473 int main() {
2474     rca_mesh_coord_t xyz;
2475     rca_get_meshcoord(0, &xyz);
2476
2477     return 0;
2478 }
2479 EOT
2480 test_linkc "whether Cray rca library is available" "yes" "no" "$CRAY_RCA_POST_LINK_OPTS -lrca"
2481 AC_DEFINE_UNQUOTED(CMK_HAS_RCALIB, $pass, [whether Cray rca library is available])
2482
2483 #### test if Cray mesh dimension query function will work ####
2484 cat > $tc <<EOT
2485 #include <rca_lib.h>
2486
2487 int main() {
2488     rca_mesh_coord_t xyz;
2489     rca_get_max_dimension(&xyz);
2490
2491     return 0;
2492 }
2493 EOT
2494 test_linkc "whether Cray rca_has get_max_dimension" "yes" "no" "$CRAY_RCA_POST_LINK_OPTS -lrca"
2495 AC_DEFINE_UNQUOTED(CMK_HAS_RCA_MAX_DIMENSION, $pass, [whether Cray rca has rca_get_max_dimension])
2496
2497 #### query Cray machine max NID if get_max_dimension not exist ####
2498
2499 if test $pass -eq 0
2500 then
2501 cmd=`which xtprocadmin 2>/dev/null`
2502 if test -n "$cmd"
2503 then
2504     #maxnid=`xtprocadmin  | tail -1  | awk '{print $1}'`
2505     # workaround for hopper
2506     (export SHELL=/bin/csh; xtprocadmin >& t.$$)
2507     maxnid=`cat t.$$  | tail -1  | awk '{print $1}'`
2508     /bin/rm -f t.$$
2509     AC_MSG_CHECKING(Cray machine maxnid)
2510     AC_MSG_RESULT("$maxnid")
2511     if test -n "$maxnid"
2512     then
2513     AC_DEFINE_UNQUOTED(CMK_CRAY_MAXNID, $maxnid, [Cray MAXNID])
2514     fi
2515 fi
2516 fi
2517
2518
2519
2520
2521 #### query Cray machine supports BANDWIDTH_INJECTION controls####
2522
2523 if test "$CMK_BUILD_MPI" = "1"
2524 then
2525 echo "BALANCED_INJECTION test disabled on MPI"
2526 elif test "$GNI_CRAYXC" = "1"
2527 then
2528 echo "BALANCED_INJECTION test disabled on Aries network"
2529 else
2530 cat > $tc <<EOT
2531 #include <stdint.h>
2532 #include <gni_pub.h>
2533
2534 int main() {
2535     gni_bi_desc_t gni_bi_desc;
2536     uint32_t gni_device_id = 0;
2537     gni_return_t gni_rc = GNI_GetBIConfig(gni_device_id, &gni_bi_desc);
2538     if (gni_rc == GNI_RC_SUCCESS) {
2539     }
2540     return 0;
2541 }
2542 EOT
2543 test_linkc "whether GNI_GetBIConfig exists" "yes" "no" "$CMK_CRAY_LIBS"
2544 AC_DEFINE_UNQUOTED(CMK_BALANCED_INJECTION_API, $pass, [whether Cray gni_pub has GNI_GetBIConfig])
2545 fi # end of BIConfig test
2546
2547
2548 fi  # end of Cray specific test
2549
2550 #### test if it can build shared library ####
2551 cat > $t <<EOT
2552 #include "stdlib.h"
2553 extern int foo();
2554 int foo1() { 
2555   void * t= malloc(2);
2556   foo();
2557   return 0;
2558 }
2559 EOT
2560 test_linkso "whether can build shared library" "yes" "no" ""
2561 if test $pass -eq 0
2562 then 
2563         add_flag 'CMK_NO_BUILD_SHARED="true"' "build-shared"
2564         add_make_flag 'CMK_NO_BUILD_SHARED:=true' 'build-shared'
2565         CMK_NO_BUILD_SHARED='true'
2566 else
2567         BUILD_SHARED=1
2568         if test "$BUILD_MPI" = "1"
2569         then
2570 cat > $t <<EOT
2571 #include "stdlib.h"
2572 #include "mpi.h"
2573 extern int foo();
2574 int foo(int argc, char ** argv) {
2575   void * t= malloc(2);
2576   foo();
2577   MPI_Init(&argc, &argv);
2578   return 0;
2579 }
2580 EOT
2581                 test_linkso "whether can build shared library with MPI" "yes" "no" ""
2582                 BUILD_SHARED=$pass
2583         fi
2584         if test $BUILD_SHARED -eq 0
2585         then
2586                 add_flag 'CMK_NO_BUILD_SHARED="true"' "build-shared"
2587                 add_make_flag 'CMK_NO_BUILD_SHARED:=true' 'build-shared'
2588                 CMK_NO_BUILD_SHARED='true'
2589         fi
2590 fi
2591
2592 #### test the version number of bproc ####
2593 if test -n "$CMK_BPROC"
2594 then
2595 cat > $t <<EOT
2596 #include <stdio.h>
2597 #include <sys/bproc.h>
2598 int main()
2599 {
2600   struct bproc_version_t vers;
2601   bproc_version(&vers);
2602   printf("%s\n", vers.version_string);
2603 }
2604 EOT
2605 test_link "whether bproc compiles" "yes" "no" "-lbproc"
2606 if test $pass -eq 1
2607 then 
2608 AC_MSG_CHECKING("bproc version")
2609 bproc_ver=`./testlink`
2610 if test x$bproc_ver = x
2611 then
2612 test_result 0 "bproc version" "ERROR" ""
2613 test_finish 1
2614 else
2615 test_result 0 "bproc version" "$bproc_ver" ""
2616 fi
2617 bproc_ver=`echo $bproc_ver | cut -d'.' -f1`
2618 AC_DEFINE_UNQUOTED(CMK_BPROC_VERSION, $bproc_ver, [bproc version])
2619 fi
2620 fi
2621
2622 #### test the if command sync exists ####
2623 AC_CHECK_PROG(SYNC, sync, sync )
2624 if test -n "$SYNC"
2625 then
2626 AC_DEFINE_UNQUOTED(CMK_HAS_SYNC, 1, [sync program])
2627 fi
2628
2629 ################## Fortran #########################
2630
2631 #echo "set F77 compiler as: $CMK_CF77"
2632 AC_MSG_CHECKING("F77 compiler as")
2633 AC_MSG_RESULT("$CMK_CF77")
2634
2635 AC_MSG_CHECKING("whether Fortran 77 compiler works")
2636 ### test fortran 77 compiler ###
2637 cat > conftest.f <<EOF
2638       SUBROUTINE FOO_foo
2639       END
2640 EOF
2641 $CMK_CF77 -c conftest.f > /dev/null 2> /dev/null
2642 if test ! -r conftest.o
2643 then
2644   AC_MSG_RESULT("no")
2645 else
2646   AC_MSG_RESULT("yes")
2647 fi
2648
2649 ### test fortran 90 compiler ###
2650 #echo "set F90 compiler as: $CMK_CF90"
2651 AC_MSG_CHECKING("F90 compiler as")
2652 AC_MSG_RESULT("$CMK_CF90")
2653
2654 AC_MSG_CHECKING("whether Fortran 90 compiler works")
2655 cat > conftest2.f90 <<EOF
2656       SUBROUTINE FOO_foo
2657       END
2658 EOF
2659 $CMK_CF90 -c conftest2.f90 > /dev/null 2> /dev/null
2660 if test ! -r conftest2.o
2661 then
2662   AC_MSG_RESULT("no")
2663 else
2664   AC_MSG_RESULT("yes")
2665   mv -f conftest2.o conftest.o
2666   USE_FORTRAN90=1
2667 fi
2668
2669 ### check fortran name mangling
2670 AC_MSG_CHECKING(subroutine name used by Fortran 90 compiler)
2671
2672 if test -r conftest.o
2673 then
2674   AC_CACHE_VAL(_cv_fortran_postfix,
2675
2676   NAME=`$CMK_NM conftest.o | grep "foo_foo__"`
2677   if test "$NAME" != ""
2678   then
2679     _cv_fortran_postfix=TWOSCORE
2680     AC_DEFINE_UNQUOTED(CMK_FORTRAN_USES_TWOSCORE, 1, [TWOSCORE])
2681   else
2682     NAME=`$CMK_NM conftest.o | grep "foo_foo_"`
2683     if test "$NAME" != ""
2684     then
2685       _cv_fortran_postfix=ONESCORE
2686       AC_DEFINE_UNQUOTED(CMK_FORTRAN_USES_ONESCORE, 1, [ONESCORE])
2687     else
2688       NAME=`$CMK_NM conftest.o | grep "foo_foo"`
2689       if test "$NAME" != ""
2690       then
2691         _cv_fortran_postfix=NOSCORE
2692         AC_DEFINE_UNQUOTED(CMK_FORTRAN_USES_NOSCORE, 1, [NOSCORE])
2693       else
2694         NAME=`$CMK_NM conftest.o | grep "FOO_FOO"`
2695         if test "$NAME" != ""
2696         then
2697           _cv_fortran_postfix=ALLCAPS
2698           AC_DEFINE_UNQUOTED(CMK_FORTRAN_USES_ALLCAPS, 1, [ALLCAPS])
2699         else
2700           echo "#################################################"
2701           echo "FORTRAN compiler generated name not supported yet"
2702           echo "#################################################"
2703         fi
2704       fi
2705     fi
2706   fi
2707   rm -f conftest.f conftest.o
2708   )
2709   AC_MSG_RESULT($_cv_fortran_postfix)
2710 else
2711   AC_MSG_RESULT("Fortran compiler not working")
2712 fi
2713
2714 ### check module name ###
2715
2716 if test "$USE_FORTRAN90" = 1
2717 then
2718   cat > conftest.f90 <<EOF
2719       MODULE testmod
2720         interface 
2721           function fpup_issizing(p)
2722           INTEGER :: p
2723           logical fpup_issizing
2724           end function
2725         end interface
2726       END MODULE
2727 EOF
2728   AC_MSG_CHECKING(Fortran 90 mod name is capital)
2729   $CMK_CF90 -c conftest.f90 > /dev/null 2> /dev/null
2730   name=`ls TESTMOD.* 2>/dev/null`
2731   if test -n "$name"
2732   then
2733         AC_MSG_RESULT("yes")
2734         add_flag 'CMK_MOD_NAME_ALLCAPS=1' "mod name capital"
2735   else
2736         AC_MSG_RESULT("no")
2737         name=`ls testmod.* 2>/dev/null`
2738   fi
2739   if test -n "$name"
2740   then
2741         AC_MSG_CHECKING(Fortran 90 mod name extension)
2742         ext=`echo $name | sed -e 's/^[[^.]]*\.//'`
2743         add_flag 'CMK_MOD_EXT="'$ext'"' "mod name extension"
2744         AC_MSG_RESULT("$ext")
2745         /bin/rm -f $name
2746   fi
2747   /bin/rm -f conftest.f90
2748 fi
2749
2750 ### test if the C++ linker succeeds with a Fortran entry point ##
2751
2752 cat > conftest.f90 <<EOF
2753       PROGRAM empty
2754       END PROGRAM
2755 EOF
2756 test_link_fortran_main() {
2757   AC_MSG_CHECKING("$1")
2758   echo "### $1" >> $charmout
2759   cat conftest.f90 >> $charmout
2760   echo $CMK_CF90 -c conftest.f90 -o test.o $4 >> $charmout
2761   $CMK_CF90 -c conftest.f90 -o test.o $4 > out 2>&1
2762   if test $? -ne 0
2763   then
2764     test_result 1 "$1" "$2" "$3"
2765   else
2766     echo $CMK_LDXX $CMK_LDXX_FLAGS $CMK_LINK_BINARY -o testlink test.o $CMK_LIBDIR $OPTS_LD $CMK_SYSLIBS $CMK_F90LIBS $CMK_F90MAINLIBS $4 $5 >> $charmout
2767     $CMK_LDXX $CMK_LDXX_FLAGS $CMK_LINK_BINARY -o testlink test.o $CMK_LIBDIR $OPTS_LD $CMK_SYSLIBS $CMK_F90LIBS $CMK_F90MAINLIBS $4 $5 >> out 2>&1
2768     ret=$?
2769     test ! -x testlink && ret=1
2770     test_result $ret "$1" "$2" "$3"
2771   fi
2772   cat out >> $charmout
2773 }
2774 test_link_fortran_main "whether the C++ linker succeeds with a Fortran entry point" "yes" "no" ""
2775 /bin/rm -f conftest.f90 test.o testlink out
2776 if test $pass -eq 1
2777 then
2778   add_flag "CMK_CAN_LINK_FORTRAN='1'" "Fortran"
2779 fi
2780
2781 ### check for OpenMP availability ###
2782 cat > $tc <<EOT
2783 #include <stdio.h>
2784 #include <omp.h>
2785
2786 int main(void)
2787 {
2788   int iam = 0, np = 1;
2789
2790   #pragma omp parallel default(shared) private(iam, np)
2791   {
2792     np = omp_get_num_threads();
2793     iam = omp_get_thread_num();
2794     printf("Hello from thread %d of %d\n", iam, np);
2795   }
2796
2797   return 0;
2798 }
2799 EOT
2800 test_linkc "whether OpenMP is supported" "yes" "no" "$CMK_C_OPENMP"
2801 if test $pass -eq 1
2802 then
2803         add_flag "CMK_HAS_OPENMP='1'" "OpenMP"
2804 fi
2805
2806 ### check for Lustre FS availability ###
2807 cat > $tc <<EOT
2808 #include <stdio.h>
2809 #include <lustre/lustreapi.h>
2810 #include <lustre/lustre_user.h>
2811
2812 int main() {
2813   llapi_printf(LLAPI_MSG_NORMAL, "Lustre FS is available");
2814   return 0;
2815 }
2816 EOT
2817 test_linkc "whether has lustre fs" "yes" "no" "-llustreapi"
2818 AC_DEFINE_UNQUOTED(CMK_HAS_LUSTREFS, $pass, [whether has lustrefs])
2819 if test $pass -eq 1
2820 then
2821   add_make_flag 'CMK_LUSTREAPI:=-llustreapi' "lustreapi"
2822 else
2823   add_make_flag 'CMK_LUSTREAPI:=' "lustreapi"
2824 fi
2825
2826
2827 # for hwloc
2828 eval "`./charmc -print-building-blocks $OPTS`"
2829 export CC="$(get_full_command_name "$CMK_SEQ_CC")"
2830 export CXX="$(get_full_command_name "$CMK_SEQ_CXX")"
2831 export CC_FOR_BUILD="$(get_full_command_name "$CMK_NATIVE_CC")"
2832 AC_SUBST(CC_FOR_BUILD)
2833 export HWLOC_FLAGS="$CHARM_CC_FLAGS"
2834 export CFLAGS="$CMK_SEQ_CC_FLAGS"
2835 export AR="$(get_full_command_name "${CMK_SEQ_AR%% *}")"
2836 enable_embedded_mode='yes'
2837 enable_static='yes'
2838 if test "$CMK_NO_BUILD_SHARED" = 'false'
2839 then
2840   enable_shared='yes'
2841   export am_libhwloc_embedded_la_rpath="-rpath $CHARMLIBSO"
2842 else
2843   enable_shared='no'
2844   export am_libhwloc_embedded_la_rpath=''
2845 fi
2846 AC_SUBST(am_libhwloc_embedded_la_rpath)
2847 enable_libnuma='no'
2848 enable_pci='no'
2849 enable_libudev='no'
2850 enable_libxml2='no'
2851 enable_visibility='no'
2852 enable_nvml='no'
2853 . hwloc/VERSION
2854 export libhwloc_so_version
2855 AC_SUBST(libhwloc_so_version)
2856
2857 echo "Configuring hwloc:"
2858 AC_CONFIG_AUX_DIR(hwloc/config)
2859 AC_CANONICAL_TARGET
2860 AC_USE_SYSTEM_EXTENSIONS
2861 LT_INIT
2862
2863 AM_INIT_AUTOMAKE([no-define])
2864
2865 AC_CONFIG_MACRO_DIR(hwloc/config)
2866 HWLOC_SET_SYMBOL_PREFIX([cmi_])
2867 HWLOC_SETUP_CORE([hwloc], [happy=yes], [happy=no])
2868 HWLOC_DO_AM_CONDITIONALS
2869 add_flag 'CMK_HWLOC_LIBS="-lhwloc_embedded '"$HWLOC_EMBEDDED_LIBS"'"' "hwloc"
2870
2871 AC_OUTPUT