14a598bb30061ca86599ac58df4ed4eab8cb925a
[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 EOT
1166 test_cxx "whether ucontext has FPU pointer" "yes" "no" ""
1167 AC_DEFINE_UNQUOTED(CMK_CONTEXT_FPU_POINTER, $pass, [whether ucontext has pointer])
1168
1169 if test $pass -eq 1
1170 then
1171 cat > $t <<EOT
1172 #include <ucontext.h>
1173
1174 int main()
1175 {
1176   ucontext_t context;
1177   context.uc_mcontext.uc_regs = 0;
1178 }
1179 EOT
1180 test_cxx "whether ucontext uses uc_regs" "yes" "no" ""
1181 AC_DEFINE_UNQUOTED(CMK_CONTEXT_FPU_POINTER_UCREGS, $pass, [whether ucontext uses uc_regs union])
1182 fi
1183
1184 cat > $t <<EOT
1185 #include <ucontext.h>
1186 vrregset_t *v_regs;
1187 ucontext_t  uc;
1188
1189 void foo()
1190 {
1191   vrregset_t *ptr = uc.uc_mcontext.v_regs;
1192 }
1193 EOT
1194 test_cxx "whether ucontext has pointer (v_regs) of vector type" "yes" "no" ""
1195 AC_DEFINE_UNQUOTED(CMK_CONTEXT_V_REGS, $pass, [whether ucontext has pointer (v_regs) of vector type])
1196
1197 #### Check ucontext and FPU pointer ####
1198 cat > $t <<EOT
1199 #include <infiniband/verbs.h>
1200 void test()
1201 {
1202     struct ibv_context    *context;
1203     int ibPort;
1204     struct ibv_port_attr attr;
1205     if (ibv_query_port(context, ibPort, &attr) != 0) return;
1206     if (attr.link_layer == IBV_LINK_LAYER_INFINIBAND)  return;
1207 }
1208 EOT
1209 test_cxx "whether ibverbs ibv_port_attr has link_layer field" "yes" "no" ""
1210 AC_DEFINE_UNQUOTED(CMK_IBV_PORT_ATTR_HAS_LINK_LAYER, $pass, [whether ibv_port_attr has link_layer field])
1211
1212
1213 ###################### C++ Compiler Features #####################
1214
1215 #### check C inline ####
1216 cat > $tc <<EOT
1217 inline static int foo()
1218 {
1219   return 1;
1220 }
1221 EOT
1222 test_cc "whether inline works in C" "yes" "no" ""
1223 AC_DEFINE_UNQUOTED(CMK_C_INLINE, $strictpass, [whether C inline works in C])
1224
1225 #### check if signed char is same as char ####
1226 cat > $t <<EOT
1227 #include <stdlib.h>
1228 class er {
1229  protected:
1230    void operator()(char &v,const char *desc=NULL) {};
1231    void operator()(signed char &v,const char *desc=NULL) {};
1232 };
1233 EOT
1234 test_cxx "whether C++ signed char and char differ" "yes" "no" ""
1235 AC_DEFINE_UNQUOTED(CMK_SIGNEDCHAR_DIFF_CHAR, $pass, [whether C++ signed char and char differ])
1236
1237 #### check if typeinfo exists and works #####
1238 cat > $t <<EOT
1239 #include <typeinfo>
1240 const char *foo(void) {
1241         int x;
1242         return typeid(x).name();
1243 }
1244 EOT
1245 test_cxx "whether typeinfo/typeid works" "ok" "no" ""
1246 AC_DEFINE_UNQUOTED(CMK_HAS_TYPEINFO, $pass, [whether typeinfo/typeid works])
1247
1248 #### check if iterator_traits is defined #####
1249 cat > $t <<EOT
1250 #include <iterator>
1251
1252 template <typename T> // T models Input Iterator
1253 typename std::iterator_traits<T>::value_type accumulate(T first, T last)
1254 {
1255       typename std::iterator_traits<T>::value_type result = 0;
1256       while(first != last)
1257             result += *first++;
1258       return result;
1259 }
1260 EOT
1261 test_cxx "whether std::iterator_traits is defined" "ok" "no" ""
1262 AC_DEFINE_UNQUOTED(CMK_HAS_ITERATOR_TRAITS, $pass, [whether iterator_traits works])
1263
1264 #### check if std::distance is defined #####
1265 cat > $t <<EOT
1266 #include <vector>
1267 #include <iterator>
1268
1269 int foo()
1270 {
1271   std::vector<int> tree;
1272   return std::distance(tree.begin(), tree.end());
1273 }
1274 EOT
1275 test_cxx "whether std::distance is defined" "ok" "no" ""
1276 AC_DEFINE_UNQUOTED(CMK_HAS_STD_DISTANCE, $pass, [whether std::distance works])
1277
1278 #### check if std::inserter is defined #####
1279 cat > $t <<EOT
1280 #include <list>
1281 #include <iterator>
1282
1283 void foo()
1284 {
1285   using namespace std;
1286   list<int> L;
1287   inserter ( L, L.end ( ) ) = 500;
1288 }
1289 EOT
1290 test_cxx "whether std::inserter is defined" "ok" "no" ""
1291 AC_DEFINE_UNQUOTED(CMK_HAS_STD_INSERTER, $pass, [whether std::inserter works])
1292
1293 #### check if C++17's std::void_t is defined #####
1294 cat > $t <<EOT
1295 #include <type_traits>
1296
1297 template<typename T, typename = std::void_t<>>
1298 struct has_pup_member : std::false_type {};
1299
1300 EOT
1301 test_cxx "whether std::void_t is defined" "ok" "no" ""
1302 AC_DEFINE_UNQUOTED(CMK_HAS_STD_VOID_T, $pass, [whether std::void_t works])
1303
1304 ####### Check support for features added by the new C11 and CPP11 standards ########
1305
1306 #### test if we can have multiple delete like this ####
1307 cat > $t <<EOT
1308 class foo {
1309 public:
1310   void operator delete(void*p){};
1311   void operator delete(void*p,int*){};
1312 };
1313 EOT
1314 test_cxx "whether operator delete can be overloaded in same class" "ok" "no" ""
1315 AC_DEFINE_UNQUOTED(CMK_MULTIPLE_DELETE, $strictpass, [whether operator delete can be overloaded in same class])
1316
1317 #### test if offsetof exists ####
1318 cat > $t <<EOT
1319 #include <stddef.h>
1320
1321 struct FooType {
1322         int f1;
1323         int f2;
1324         double f3;
1325 };
1326
1327 void foo()
1328 {
1329   int off = offsetof(FooType, f2);
1330 }
1331 EOT
1332 test_cxx "whether offsetof is defined" "yes" "no" ""
1333 AC_DEFINE_UNQUOTED(CMK_HAS_OFFSETOF, $pass, [whether offsetof exists])
1334
1335 #### test if we can use gcc x86 assembly like this ####
1336 cat > $t <<EOT
1337 double foo(void)
1338 {
1339   unsigned long long int v=0;
1340   int *lo=0+(int *)&v;
1341   int *hi=1+(int *)&v;
1342   __asm__ __volatile__(
1343       "rdtsc; movl %%edx,%0; movl %%eax,%1"
1344       : /* output  */ "=m" (*hi), "=m" (*lo)
1345       : /* input */
1346       : /* trashes */ "%edx", "%eax"
1347   );
1348   return v;
1349 }
1350 EOT
1351 test_cxx "whether GCC x86 assembly works" "yes" "no" ""
1352 AC_DEFINE_UNQUOTED(CMK_GCC_X86_ASM, $strictpass, [Allows gcc x86 assembly.])
1353
1354 #### test if we can use gcc x86 assembly like this ####
1355 if test $strictpass = 1
1356 then
1357 cat > $t <<EOT
1358 int foo(void)
1359 {
1360   int x;
1361   asm("lock incl %0" :: "m" (x));
1362   asm("lock decl %0" :: "m" (x));
1363   return x;
1364 }
1365 EOT
1366 test_cxx "whether GCC x86 assembly for atomic increment works" "yes" "no" ""
1367 AC_DEFINE_UNQUOTED(CMK_GCC_X86_ASM_ATOMICINCREMENT, $strictpass, [Allows gcc x86 assembly for atomic increment.])
1368 fi
1369
1370 #### test if we can use asm eieio assembly like this ####
1371 cat > $t <<EOT
1372 double foo(void)
1373 {
1374         unsigned long long int x;
1375         asm volatile("eieio" ::: "memory");
1376         return x;
1377 }
1378 EOT
1379 test_cxx "whether asm eieio assembly works" "yes" "no" ""
1380 AC_DEFINE_UNQUOTED(CMK_PPC_ASM, $strictpass, [Allows asm eieio assembly.])
1381
1382
1383
1384 #### test if we can use __thread ####
1385 cat > $t <<EOT
1386 __thread unsigned long long int x;
1387 static __thread  int y;
1388 void foo(void)
1389 {
1390         x = 1;
1391         y = 1;
1392 }
1393 EOT
1394 test_cxx "whether __thread (Thread Local Storage) is supported" "yes" "no" ""
1395 AC_DEFINE_UNQUOTED(CMK_HAS_TLS_VARIABLES, $strictpass, [Allows __thread.])
1396
1397 #### check __sync_add_and_fetch ####
1398 cat > $tc <<EOT
1399 #include <stdio.h>
1400 int main()
1401 {
1402   int t=1;
1403   __sync_add_and_fetch(&t, 1);
1404   return 1;
1405 }
1406 EOT
1407 test_linkc "whether synchronization primitives (__sync_add_and_fetch) works in C" "yes" "no" ""
1408 AC_DEFINE_UNQUOTED(CMK_C_SYNC_ADD_AND_FETCH_PRIMITIVE, $pass, [whether sync_add_and_fetch primitive works in C])
1409
1410 #### check __sync_synchronize ####
1411 cat > $tc <<EOT
1412 #include <stdio.h>
1413 int main()
1414 {
1415   __sync_synchronize();
1416 }
1417 EOT
1418
1419 test_linkc "whether synchronization primitives (__sync_synchronize) works in C" "yes" "no" ""
1420
1421 AC_DEFINE_UNQUOTED(CMK_C_SYNC_SYNCHRONIZE_PRIMITIVE, $pass, [whether sync_synchronize primitives works in C])
1422
1423
1424 ### test for __executable_start ###
1425
1426 cat > $tc <<EOT
1427 extern int __executable_start;
1428 int main()
1429 {
1430   return __executable_start;
1431 }
1432 EOT
1433 test_linkc "whether has __executable_start" "yes" "no" ""
1434 AC_DEFINE_UNQUOTED([CMK_HAS_EXECUTABLE_START], $pass, [whether has __executable_start])
1435
1436 ### test if switching TLS register ###
1437 if test $in64bit = 1
1438 then
1439 cat > $t <<EOT
1440 void switchTLS() {
1441   void * m1, * m2;
1442   asm volatile ("movq %%fs:0x0, %0\n\t"
1443                 "movq %1, %%fs:0x0\n\t"
1444                 : "=&r"(m1)
1445                 : "r"(m2));
1446 }
1447 EOT
1448 test_cxx "whether switching TLS register (64-bit) is supported" "yes" "no" ""
1449 AC_DEFINE_UNQUOTED(CMK_TLS_SWITCHING_X86_64, $strictpass, [Allows switching TLS on x86_64.])
1450 else
1451 cat > $t <<EOT
1452 void switchTLS() {
1453   void * m1, * m2;
1454   asm volatile ("movl %%gs:0x0, %0\n\t"
1455                 "movl %1, %%gs:0x0\n\t"
1456                 : "=&r"(m1)
1457                 : "r"(m2));
1458 }
1459 EOT
1460 test_cxx "whether switching TLS register (32-bit) is supported" "yes" "no" ""
1461 AC_DEFINE_UNQUOTED(CMK_TLS_SWITCHING_X86, $strictpass, [Allows switching TLS on x86.])
1462 fi
1463
1464 ### test for dl_iterate_phdr ###
1465
1466 cat > $tc <<EOT
1467 #ifndef _GNU_SOURCE
1468 # define _GNU_SOURCE
1469 #endif
1470 #ifndef __USE_GNU
1471 # define __USE_GNU
1472 #endif
1473 #include <link.h>
1474 #include <stddef.h>
1475 static int callback(struct dl_phdr_info* info, size_t size, void* data)
1476 {
1477   return 0;
1478 }
1479 int main()
1480 {
1481   dl_iterate_phdr(callback, NULL);
1482   return 0;
1483 }
1484 EOT
1485 test_linkc "whether has dl_iterate_phdr" "yes" "no" ""
1486 AC_DEFINE_UNQUOTED([CMK_HAS_DL_ITERATE_PHDR], $pass, [whether has dl_iterate_phdr])
1487
1488
1489 ### test for __malloc_hook ###
1490
1491 cat > $tc <<EOT
1492 extern int __malloc_hook;
1493 int main()
1494 {
1495   return __malloc_hook;
1496 }
1497 EOT
1498 test_linkc "whether has __malloc_hook" "yes" "no" ""
1499 AC_DEFINE_UNQUOTED([CMK_HAS_MALLOC_HOOK], $pass, [whether has __malloc_hook])
1500 add_make_flag "CMK_HAS_MALLOC_HOOK:=$pass" 'whether has __malloc_hook'
1501
1502
1503 #### test if we can build OFI ####
1504 if test "$CMK_BUILD_OFI" = 1
1505 then
1506 cat > $tc <<EOT
1507 #include <rdma/fabric.h>
1508 int main(int argc, char **argv)
1509 {
1510   struct fi_info *providers;
1511   int ret = fi_getinfo(FI_VERSION(1,0), NULL, NULL, 0ULL, NULL, &providers);
1512   return 0;
1513 }
1514 EOT
1515 test_cc "whether build on OFI" "yes" "no" "-lfabric"
1516 AC_DEFINE_UNQUOTED(CMK_BUILD_ON_OFI, $strictpass, [build OFI.])
1517 BUILD_OFI=$strictpass
1518
1519 if test $BUILD_OFI -eq 0
1520 then
1521   echo "Error: Unable to compile OFI"
1522   test_finish 1
1523 else
1524   test_linkc "whether -lfabric" "ok" "no" "-lfabric"
1525   if test $pass -eq 0
1526   then
1527     #test for psm incompatibility
1528     PSM_COMPAT_DIR=/usr/lib64/psm2-compat
1529     if test -d $PSM_COMPAT_DIR
1530     then
1531       add_flag CMK_LIBDIR='"$CMK_LIBDIR -Wl,-rpath=/usr/lib64/psm2-compat"' "psm2-compat lib"
1532       CMK_LIBDIR="$CMK_LIBDIR -Wl,-rpath=/usr/lib64/psm2-compat"
1533       test_linkc "whether -lfabric after adding psm2-compatible library" "ok" "no" "-lfabric"
1534       if test $pass -eq 0
1535       then
1536         echo "Error: -lfabric not found or not working. Pass '--basedir=/path/to/dir/' if -lfabric is located in a different directory"
1537         test_finish 1
1538       fi
1539     else
1540       echo "Error: -lfabric not working, $PSM_COMPAT_DIR not found"
1541       echo "Pass '--basedir=/path/to/dir/' if -lfabric is located in a different directory"
1542       test_finish 1
1543     fi
1544   fi
1545 fi
1546
1547 fi
1548
1549 #### test if we can build MPI ####
1550 if test "$CMK_BUILD_MPI" = 1
1551 then
1552
1553 cat > $tc <<EOT
1554 #include "mpi.h"
1555 int main(int argc, char **argv)
1556 {
1557   MPI_Init(&argc, &argv);
1558   return 0;
1559 }
1560 EOT
1561 mv -f ../include/mpi.h ../include/mpi.h.bak 2>/dev/null
1562 test_cc "whether build on MPI" "yes" "no" ""
1563 AC_DEFINE_UNQUOTED(CMK_BUILD_ON_MPI, $strictpass, [build MPI.])
1564 BUILD_MPI=$strictpass
1565
1566 if test $BUILD_MPI -eq 0
1567 then
1568   echo "Error: Cannot compile an MPI program"
1569   test_finish 1
1570 fi
1571
1572 if test $BUILD_MPI -eq 1
1573 then
1574   test_linkc "whether need to specify MPI library" "no" "yes" ""
1575   if test $pass -ne 1
1576   then
1577     if test -z "$CMK_MPI_LIB"
1578     then
1579       test_linkc "whether -lmpich" "ok" "no" "-lmpich"
1580       if test $pass -eq 1
1581       then
1582         add_flag CMK_SYSLIBS='"$CMK_SYSLIBS -lmpich"' "mpi lib"
1583       else
1584         test_linkc "whether -lmpi" "ok" "no" "-lmpi"
1585         if test $pass -eq 1
1586         then
1587                 add_flag CMK_SYSLIBS='"$CMK_SYSLIBS -lmpi"' "mpi lib"
1588         else
1589                 echo "Error: Cannot find MPI library"
1590                 test_finish 1
1591         fi
1592       fi
1593     else
1594       add_flag CMK_SYSLIBS='"$CMK_SYSLIBS $CMK_MPI_LIB"' "mpi lib"
1595     fi
1596   fi
1597 fi
1598
1599 if test "$BUILD_MPI" = "1"
1600 then
1601 cat > $t <<EOT
1602 #include "mpi.h"
1603 int main(int argc, char **argv)
1604 {
1605   int thread_level, provided;
1606   thread_level = MPI_THREAD_FUNNELED;
1607   MPI_Init_thread(&argc, &argv, thread_level, &provided);
1608 }
1609 EOT
1610 test_cxx "whether MPI_Init_thread is supported" "yes" "no" ""
1611 AC_DEFINE_UNQUOTED(CMK_MPI_INIT_THREAD, $strictpass, [Allows MPI_Init_thread.])
1612 fi
1613 mv -f ../include/mpi.h.bak ../include/mpi.h 2>/dev/null
1614
1615 fi
1616
1617 if test "$BUILD_MPI" = "1"
1618 then
1619
1620 cat > $t <<EOT
1621 #include <stdio.h>
1622 #include <mpi.h>
1623
1624 int main (int argc, char** argv) {
1625   return 0;
1626 }
1627 EOT
1628 test_cxx "whether macro conflicts occurs due to C++ MPI bindings" "no" "yes" ""
1629 AC_DEFINE_UNQUOTED(CMK_CXX_MPI_BINDINGS, $strictpass, [Disables conflicting macros.])
1630 fi
1631
1632
1633 ################### Syscalls and Libraries ###################
1634
1635 #### test for getrusage with RUSAGE_THREAD ###
1636 cat > $tc <<EOT
1637 #ifndef _GNU_SOURCE
1638 # define _GNU_SOURCE
1639 #endif
1640 #ifndef __USE_GNU
1641 # define __USE_GNU
1642 #endif
1643 #include <sys/time.h>
1644 #include <sys/resource.h>
1645 int main() {
1646   struct rusage usage;
1647   getrusage(RUSAGE_THREAD, &usage);
1648   return 0;
1649 }
1650 EOT
1651 test_linkc "whether getrusage accepts RUSAGE_THREAD" "yes" "no" ""
1652 AC_DEFINE_UNQUOTED(CMK_HAS_RUSAGE_THREAD, $pass, [whether getrusage accepts RUSAGE_THREAD])
1653
1654 #### test for asctime ###
1655
1656 cat > $tc <<EOT
1657 #include <time.h>
1658 int main() {
1659   struct tm *local;
1660   time_t t;
1661   t = time(NULL);
1662   local = localtime(&t);
1663   asctime(local);
1664   return 0;
1665 }
1666 EOT
1667 test_linkc "whether has asctime" "yes" "no" ""
1668 AC_DEFINE_UNQUOTED(CMK_HAS_ASCTIME, $pass, [whether has asctime])
1669
1670 #### test for log2 ###
1671 cat > $t <<EOT
1672 #include <math.h>
1673 int main() {
1674   int i = log2(10);
1675   return 0;
1676 }
1677 EOT
1678 test_link "whether has log2" "yes" "no" ""
1679 AC_DEFINE_UNQUOTED(CMK_HAS_LOG2, $pass, [whether has log2])
1680
1681 #### test for sqrtf ###
1682 cat > $t <<EOT
1683 #include <math.h>
1684 int main() {
1685   float i = sqrtf((float)10.0);
1686   return 0;
1687 }
1688 EOT
1689 test_link "whether has sqrtf" "yes" "no" ""
1690 AC_DEFINE_UNQUOTED(CMK_HAS_SQRTF, $pass, [whether has sqrtf])
1691
1692 #### test for fabsf ###
1693 cat > $t <<EOT
1694 #include <math.h>
1695 int main() {
1696   float i = fabsf((float)10.0);
1697   return 0;
1698 }
1699 EOT
1700 test_link "whether has fabsf" "yes" "no" ""
1701 AC_DEFINE_UNQUOTED(CMK_HAS_FABSF, $pass, [whether has fabsf])
1702
1703 #### test for mkstemp ###
1704 cat > $t <<EOT
1705 #include <stdlib.h>
1706 #include <string.h>
1707 int main() {
1708   char fname[[128]];
1709   strcpy(fname, "/tmp/fdXXX.XXX");
1710   mkstemp(fname);
1711   return 0;
1712 }
1713 EOT
1714 test_link "whether has mkstemp" "yes" "no" ""
1715 AC_DEFINE_UNQUOTED(CMK_USE_MKSTEMP, $pass, [whether has mkstemp])
1716
1717 #### test for system ###
1718 cat > $t <<EOT
1719 #include <stdlib.h>
1720 int main() {
1721   system("/bin/ls");
1722   return 0;
1723 }
1724 EOT
1725 test_link "whether has system" "yes" "no" ""
1726 AC_DEFINE_UNQUOTED(CMK_HAS_SYSTEM, $pass, [whether has system])
1727
1728 #### test for sync() ###
1729 cat > $t <<EOT
1730 #include <unistd.h>
1731 int main() {
1732   sync();
1733   return 0;
1734 }
1735 EOT
1736 test_link "whether has sync()" "yes" "no" ""
1737 AC_DEFINE_UNQUOTED(CMK_HAS_SYNC_FUNC, $pass, [whether has sync])
1738
1739 #### test for fsync() ###
1740 cat > $t <<EOT
1741 #include <unistd.h>
1742 int main() {
1743   fsync(0);
1744   return 0;
1745 }
1746 EOT
1747 test_link "whether has fsync()" "yes" "no" ""
1748 AC_DEFINE_UNQUOTED(CMK_HAS_FSYNC_FUNC, $pass, [whether has fsync])
1749
1750 #### test for fdatasync() ###
1751 cat > $t <<EOT
1752 #include <unistd.h>
1753 int main() {
1754   fdatasync(0);
1755   return 0;
1756 }
1757 EOT
1758 test_link "whether has fdatasync()" "yes" "no" ""
1759 AC_DEFINE_UNQUOTED(CMK_HAS_FDATASYNC_FUNC, $pass, [whether has fdatasync])
1760
1761 #### test for sbrk ###
1762 cat > $t <<EOT
1763 #include <unistd.h>
1764 int main() {
1765   void *ptr  = sbrk(0); 
1766 }
1767 EOT
1768 test_link "whether has sbrk" "yes" "no" ""
1769 AC_DEFINE_UNQUOTED(CMK_HAS_SBRK, $pass, [whether has sbrk])
1770
1771 #### test for _setjmp/_longjmp ###
1772 cat > $t <<EOT
1773 #include <setjmp.h>
1774 int main() {
1775   jmp_buf buf;
1776   _setjmp(buf);
1777   _longjmp(buf, 0);
1778 }
1779 EOT
1780 test_link "whether has _setjmp/_longjmp" "yes" "no" ""
1781 AC_DEFINE_UNQUOTED(CMK_HAS_UNDERSCORE_SETJMP, $pass, [whether has _setjmp/_longjmp])
1782
1783 #### test for mstats ###
1784 cat > $t <<EOT
1785 #include <malloc.h>
1786 int main() {
1787   struct mstats ms = mstats();
1788 }
1789 EOT
1790 test_link "whether has mstats" "yes" "no" ""
1791 AC_DEFINE_UNQUOTED(CMK_HAS_MSTATS, $pass, [whether has mstats])
1792
1793 #### test for mallinfo ###
1794 cat > $t <<EOT
1795 #include <malloc.h>
1796 int main() {
1797   struct mallinfo mi = mallinfo();
1798 }
1799 EOT
1800 test_link "whether has mallinfo" "yes" "no" ""
1801 AC_DEFINE_UNQUOTED(CMK_HAS_MALLINFO, $pass, [whether has mallinfo])
1802
1803 #### test for __morecore ###
1804 cat > $t <<EOT
1805 #include <cstddef>
1806 int main() {
1807   extern void *(*__morecore)(ptrdiff_t);
1808   __morecore(0);
1809   return 0;
1810 }
1811 EOT
1812 test_link "whether expects __morecore symbol" "yes" "no" ""
1813 AC_DEFINE_UNQUOTED(CMK_EXPECTS_MORECORE, $pass, [whether expects __morecore symbol])
1814
1815 #### test for popen ###
1816 cat > $t <<EOT
1817 #include <stdio.h>
1818 int main() {
1819   FILE *p = popen("/bin/ps", "r");
1820   pclose(p);
1821 }
1822 EOT
1823 test_link "whether has popen" "yes" "no" ""
1824 AC_DEFINE_UNQUOTED(CMK_HAS_POPEN, $pass, [whether has popen])
1825
1826 #### test for poll ###
1827 cat > $t <<EOT
1828 #include <poll.h>
1829 void foo(void) { 
1830   struct pollfd pos[[3]];
1831   poll(pos, 1, 1);
1832 }
1833 EOT
1834 test_cxx "whether has poll" "yes" "no" ""
1835 AC_DEFINE_UNQUOTED(CMK_USE_POLL, $pass, [whether the poll syscall exists])
1836
1837 #### check if getpagesize exists ####
1838 cat > $tc <<EOT
1839 #include <unistd.h>
1840
1841 int main(int argc, char **argv) {
1842     int s = getpagesize();
1843 }
1844 EOT
1845 test_linkc "whether has getpagesize" "yes" "no" ""
1846 AC_DEFINE_UNQUOTED(CMK_HAS_GETPAGESIZE, $pass, [whether getpagesize exists])
1847
1848 #### check if getpid exists ####
1849 cat > $tc <<EOT
1850 #include <sys/types.h>
1851 #include <unistd.h>
1852
1853 int main(int argc, char **argv) {
1854     pid_t pid = getpid();
1855 }
1856 EOT
1857 test_linkc "whether has getpid" "yes" "no" ""
1858 AC_DEFINE_UNQUOTED(CMK_HAS_GETPID, $pass, [whether getpid exists])
1859
1860 #### check if kill exists ####
1861 cat > $tc <<EOT
1862 #include <sys/types.h>
1863 #include <unistd.h>
1864 #include <signal.h>
1865
1866 int main(int argc, char**argv) 
1867 {
1868     pid_t pid = getpid();
1869     kill(pid, 9);
1870 }
1871 EOT
1872 test_linkc "whether has kill" "yes" "no" ""
1873 AC_DEFINE_UNQUOTED(CMK_HAS_KILL, $pass, [whether kill exists])
1874
1875 #### test for setpriority ###
1876 cat > $t <<EOT
1877 #include <sys/time.h>
1878 #include <sys/resource.h>
1879 void foo(void) { 
1880   setpriority(PRIO_PROCESS, 0, 0);
1881 }
1882 EOT
1883 test_cxx "whether has setpriority" "yes" "no" ""
1884 AC_DEFINE_UNQUOTED(CMK_HAS_SETPRIORITY, $pass, [whether the setpriority exists])
1885
1886 #### test for system ###
1887 cat > $t <<EOT
1888 #include "ckdll_system.C"
1889 EOT
1890 test_cxx "whether to use signal-safe system() " "yes" "no" ""
1891 AC_DEFINE_UNQUOTED(CMK_SIGSAFE_SYSTEM, $pass, [whether to use signal-safe system()])
1892
1893 ### test sched_setaffinity ####
1894 cat > $tc <<EOT
1895 #define _GNU_SOURCE
1896 #include <sched.h>
1897
1898 int main()
1899 {
1900   cpu_set_t cpuset;
1901   CPU_ZERO(&cpuset);
1902   CPU_SET(0, &cpuset);
1903   if (sched_setaffinity(0, sizeof(cpuset), &cpuset) < 0) {
1904     return -1;
1905   }
1906   return 0;
1907 }
1908 EOT
1909 test_linkc "whether sched_setaffinity call exists" "yes" "no" ""
1910 AC_DEFINE_UNQUOTED(CMK_HAS_SETAFFINITY, $pass, [whether the sched_setaffinity() exists])
1911
1912 ### test pthread_setaffinity_np ####
1913 cat > $tc <<EOT
1914 #include <stdlib.h>
1915 #include <stdio.h>
1916 #include <unistd.h>
1917 #include <pthread.h>
1918
1919 int main()
1920 {
1921   unsigned long mask = 0xffffffff;
1922   unsigned int len = sizeof(mask);
1923
1924   if (pthread_setaffinity_np(pthread_self(), len, &mask) < 0) {
1925     return -1;
1926   }
1927   return 0;
1928 }
1929 EOT
1930 test_linkc "whether pthread_setaffinity_np call exists" "yes" "no" "-lpthread"
1931 AC_DEFINE_UNQUOTED(CMK_HAS_PTHREAD_SETAFFINITY, $pass, [whether the pthread_setaffinity_np() exists])
1932
1933 ### test pthread_spin_lock ####
1934 cat > $tc <<EOT
1935 #include <stdlib.h>
1936 #include <stdio.h>
1937 #include <unistd.h>
1938 #include <pthread.h>
1939
1940 int main()
1941 {
1942   pthread_spinlock_t  lock;
1943
1944   pthread_spin_init(&lock, 0);
1945
1946   pthread_spin_lock(&lock);
1947
1948   return 0;
1949 }
1950 EOT
1951 test_linkc "whether pthread_spin_lock exists" "yes" "no" "-lpthread"
1952 AC_DEFINE_UNQUOTED(CMK_HAS_SPINLOCK, $pass, [whether the pthread_spin_lock exists])
1953
1954 ### check libnuma on Linux ####
1955 if test "$WITH_NUMA" = "yes"
1956 then
1957 cat > $tc <<EOT
1958 #include <stdlib.h>
1959 #include <stdio.h>
1960 #include <linux/mempolicy.h>
1961 #include <numaif.h>
1962 #include <numa.h>
1963
1964 int main()
1965 {
1966   if (get_mempolicy(NULL, NULL, 0, 0, 0) == 0) return 0;
1967   return -1;
1968 }
1969 EOT
1970 test_linkc "whether libnuma exists" "yes" "no" "-lnuma"
1971 AC_DEFINE_UNQUOTED(CMK_HAS_NUMACTRL, $pass, [whether NUMA control related functions exist])
1972 if test $pass -eq 1
1973 then
1974         add_flag 'CMK_SYSLIBS="$CMK_SYSLIBS -lnuma"' "libnuma"
1975 fi
1976 fi
1977
1978 #### check bindprocessors on AIX ####
1979 cat > $tc <<EOT
1980 #include <stdlib.h>
1981 #include <stdio.h>
1982 #include <unistd.h>
1983
1984 #include <sys/processor.h>
1985
1986 int main()
1987 {
1988   int retValue = 0;
1989   int pid;
1990   pid = getpid();
1991   if (bindprocessor(BINDPROCESS, pid, 0) == -1) return -1;
1992   return 0;
1993 }
1994 EOT
1995 test_linkc "whether bindprocessor call exists" "yes" "no" ""
1996 AC_DEFINE_UNQUOTED(CMK_HAS_BINDPROCESSOR, $pass, [whether the bindprocessor()
1997 exists])
1998
1999
2000 #### check if dlopen works ####
2001 skip_dl=0
2002 # for bproc, ignore -ldl
2003 test -n "$CMK_BPROC" && skip_dl=1
2004 test -n "$CMK_NO_DL" && skip_dl=1
2005 dl_opt='-ldl'
2006 #workaround for pgcc 4.0, -ldl crash linking, so use -Wl,-ldl to skip the prelinker.
2007 case "$CMK_CXX" in
2008 pgCC*) dl_opt='-Wl,-ldl' ;;
2009 esac
2010
2011 if test $skip_dl -eq 0 
2012 then
2013
2014 cat > $t <<EOT
2015 #include "ckdll_dlopen.C"
2016 int main() {
2017         CkDll dll("foo.so");
2018         return 0;
2019 }
2020 EOT
2021 test_link "whether dlopen links without $dl_opt" "yes" "no" ""
2022 noldl=$pass
2023 test_link "whether dlopen links with $dl_opt" "yes" "no" "$dl_opt"
2024 if test $pass -eq 1
2025 then 
2026 #dlopen requires -ldl: add it to our link line
2027         add_flag CMK_LIBS='"$CMK_LIBS '$dl_opt'"' "dlopen"
2028 fi
2029
2030 if test $pass -eq 1 -o $noldl -eq 1
2031 then
2032 # One version or another of dlopen worked: compile it in
2033         AC_DEFINE_UNQUOTED(CMK_DLL_USE_DLOPEN, 1, [dlopen])
2034 fi
2035
2036 cat > $tc <<EOT
2037 #ifndef _GNU_SOURCE
2038 # define _GNU_SOURCE
2039 #endif
2040 #ifndef __USE_GNU
2041 # define __USE_GNU
2042 #endif
2043 #include <dlfcn.h>
2044 #include <stddef.h>
2045 int main()
2046 {
2047   return dlsym(RTLD_DEFAULT, "main") != NULL;
2048 }
2049 EOT
2050 test_cc "whether has RTLD_DEFAULT" "yes" "no" ""
2051 AC_DEFINE_UNQUOTED(CMK_HAS_RTLD_DEFAULT, $pass, [whether has RTLD_DEFAULT])
2052
2053 cat > $tc <<EOT
2054 #ifndef _GNU_SOURCE
2055 # define _GNU_SOURCE
2056 #endif
2057 #ifndef __USE_GNU
2058 # define __USE_GNU
2059 #endif
2060 #include <dlfcn.h>
2061 #include <stddef.h>
2062 int main()
2063 {
2064   return dlsym(RTLD_NEXT, "main") != NULL;
2065 }
2066 EOT
2067 test_cc "whether has RTLD_NEXT" "yes" "no" ""
2068 AC_DEFINE_UNQUOTED(CMK_HAS_RTLD_NEXT, $pass, [whether has RTLD_NEXT])
2069
2070 ### test gethostname ####
2071 cat > $tc <<EOT
2072 #ifdef _WIN32
2073 #include <Winsock2.h>
2074 #else
2075 #include <stdlib.h>
2076 #include <stdio.h>
2077 #include <unistd.h>
2078 #endif
2079
2080 int main()
2081 {
2082   char hostname[[1000]];
2083   gethostname(hostname, 999);
2084   return 0;
2085 }
2086 EOT
2087 test_cc "whether gethostname call exists" "yes" "no" ""
2088 AC_DEFINE_UNQUOTED(CMK_HAS_GETHOSTNAME, $pass, [whether gethostname() exists])
2089
2090 #### check if getProcAddress works ####
2091 cat > $t <<EOT
2092 #include "ckdll_win32.C"
2093 EOT
2094 test_cxx "whether getProcAddress works" "yes" "no" ""
2095 AC_DEFINE_UNQUOTED(CMK_DLL_USE_WIN32, $pass, [whether getProcAddress works])
2096
2097 fi    # end of skip_dl
2098
2099 #### check if socklen_t exists ####
2100 cat > $t <<EOT
2101 #include <sys/types.h>
2102 #include <sys/socket.h>
2103
2104 void foo(void) {
2105         int i;
2106         socklen_t s=sizeof(i);
2107 }
2108 EOT
2109 test_cxx "whether has socklen_t" "yes" "no" ""
2110 AC_DEFINE_UNQUOTED(CMK_HAS_SOCKLEN, $pass, [whether has socklen_t])
2111
2112 ### test getifaddrs ####
2113 cat > $tc <<EOT
2114 #include <netinet/in.h> /* for sockaddr_in */
2115 #include <ifaddrs.h> /* for getifaddrs */
2116 #include <net/if.h> /* for IFF_RUNNING */
2117
2118 int main()
2119 {
2120   struct ifaddrs *interfaces=0;
2121   if( getifaddrs(&interfaces) == 0 ) {
2122         struct ifaddrs *interface;
2123         for( interface=interfaces; interface; interface=interface->ifa_next ) {
2124             if( (interface->ifa_flags & IFF_UP) && ! (interface->ifa_flags & IFF_LOOPBACK) ) {
2125                 const struct sockaddr_in *addr = (const struct sockaddr_in*)interface->ifa_addr;
2126                 if( addr && addr->sin_family==AF_INET ) {
2127                     break;
2128                 }
2129             }
2130         }
2131         freeifaddrs(interfaces);
2132   }
2133 }
2134 EOT
2135 test_linkc "whether getifaddrs call exists" "yes" "no" ""
2136 AC_DEFINE_UNQUOTED(CMK_HAS_GETIFADDRS, $pass, [whether getifaddrs() exists])
2137
2138 #### check if mmap exists ####
2139 cat > $t <<EOT
2140 #include <sys/types.h>
2141 #include <sys/mman.h>
2142
2143 void *foo(void *a,int l,int fd) {
2144         return mmap((caddr_t)a,l,PROT_READ+PROT_WRITE,
2145                  MAP_FIXED+MAP_PRIVATE,fd,0);
2146 }
2147 EOT
2148 test_cxx "whether the mmap() syscall exists" "yes" "no" ""
2149 AC_DEFINE_UNQUOTED(CMK_HAS_MMAP, $pass, [whether the mmap() syscall exists])
2150 add_flag "CMK_HAS_MMAP=$pass"
2151 add_make_flag "CMK_HAS_MMAP:=$pass"
2152
2153 #### check if mmap accepts MAP_ANON ####
2154 cat > $t <<EOT
2155 #include <sys/types.h>
2156 #include <sys/mman.h>
2157
2158 void *foo(void *a,int l) {
2159         return mmap((caddr_t)a,l,PROT_READ+PROT_WRITE,
2160                 MAP_FIXED+MAP_PRIVATE+MAP_ANON,-1,0);
2161 }
2162 EOT
2163 test_cxx "whether mmap() accepts MAP_ANON" "yes" "no" ""
2164 AC_DEFINE_UNQUOTED(CMK_HAS_MMAP_ANON, $pass, [whether mmap() accepts MAP_ANON])
2165
2166 #### check if mmap accepts MAP_NORESERVE ####
2167 cat > $t <<EOT
2168 #include <sys/types.h>
2169 #include <sys/mman.h>
2170
2171 void *foo(void *a,int l) {
2172         return mmap((caddr_t)a,l,PROT_READ+PROT_WRITE,
2173                 MAP_FIXED+MAP_PRIVATE+MAP_NORESERVE,-1,0);
2174 }
2175 EOT
2176 test_cxx "whether mmap() accepts MAP_NORESERVE" "yes" "no" ""
2177 AC_DEFINE_UNQUOTED(CMK_HAS_MMAP_NORESERVE, $pass, [whether mmap() accepts MAP_NORESERVE])
2178
2179 #### check if get_myaddress exists ####
2180 cat > $t <<EOT
2181 #include <rpc/rpc.h>
2182
2183 void foo(void *a) {
2184     get_myaddress((struct sockaddr_in*)a);
2185 }
2186 EOT
2187 test_cxx "whether has get_myaddress" "yes" "no" ""
2188 AC_DEFINE_UNQUOTED(CMK_HAS_GET_MYADDRESS, $pass, [whether has get_myaddress])
2189
2190 #### check if mprotect exists ####
2191 cat > $t <<EOT
2192 #include <stdio.h>
2193 #include <sys/mman.h>
2194
2195 void foo(void *a,int l,int fd) {
2196      void *pg = NULL;
2197      size_t pagesize = 4096;
2198      mprotect(pg, pagesize, PROT_READ | PROT_WRITE);
2199 }
2200 EOT
2201 test_cxx "whether has mprotect" "yes" "no" ""
2202 AC_DEFINE_UNQUOTED(CMK_HAS_MPROTECT, $pass, [whether has mprotect])
2203
2204 #### check if support for SHM through CMA exists ####
2205 cat > $t <<EOT
2206 #define _GNU_SOURCE
2207 #include <sys/uio.h>
2208 #include <errno.h>
2209 int main() {
2210   pid_t pid;
2211   struct iovec *local, *remote;
2212   int nread = process_vm_readv(pid, local, 1, remote, 1, 0);
2213   nread = process_vm_writev(pid, local, 1, remote, 1, 0);
2214   return errno;
2215 }
2216 EOT
2217 test_link "whether has support for shm transport using Cross Memory Attach" "yes" "no" ""
2218 AC_DEFINE_UNQUOTED(CMK_HAS_CMA, $pass, [whether supports cma])
2219
2220 #### check if -rdynamic works ####
2221 cat > $t <<EOT
2222 int main() {
2223   return 0;
2224 }
2225 EOT
2226 TRACE_LINK_FLAG=''
2227 CAN_EXPORT_SYMBOLS='0'
2228 for i in '-rdynamic' '-Wl,--export-dynamic'; do
2229   test_link "whether has $i" "yes" "no" "$i"
2230   if test "$strictpass" = '1'; then
2231     TRACE_LINK_FLAG="$i"
2232     CAN_EXPORT_SYMBOLS='1'
2233     break
2234   fi
2235 done
2236
2237 if test "$CAN_EXPORT_SYMBOLS" = '1'; then
2238   add_flag 'CMK_LD="$CMK_LD '$TRACE_LINK_FLAG'"' "exporting program symbols to shared objects"
2239   add_flag 'CMK_LDXX="$CMK_LDXX '$TRACE_LINK_FLAG'"' "exporting program symbols to shared objects"
2240 fi
2241
2242 #### check if glibc backtrace exists ####
2243 cat > $t <<EOT
2244 #include "cmibacktrace.c"
2245
2246 int main() {
2247         int nLevels=1;
2248         void *stack;
2249         CmiBacktraceRecord(&stack,0,&nLevels);
2250         return 0;
2251 }
2252 EOT
2253 test_link "whether glibc backtrace works" "yes" "no" "-DCMK_USE_BACKTRACE=1 $TRACE_LINK_FLAG"
2254 AC_DEFINE_UNQUOTED(CMK_USE_BACKTRACE, $pass, [whether glibc backtrace works])
2255
2256 #### test sleep ####
2257 cat > $t <<EOT
2258 #include <unistd.h>
2259 int main() {
2260   sleep(1);
2261   return 0;
2262 }
2263 EOT
2264 test_cxx "whether has sleep " "yes" "no" ""
2265 AC_DEFINE_UNQUOTED(CMK_HAS_SLEEP, $pass, [whether has sleep])
2266
2267 #### test usleep ####
2268 cat > $t <<EOT
2269 #include <unistd.h>
2270 int main() {
2271   usleep(100);
2272   return 0;
2273 }
2274 EOT
2275 test_cxx "whether has usleep " "yes" "no" ""
2276 AC_DEFINE_UNQUOTED(CMK_HAS_USLEEP, $pass, [whether has usleep])
2277
2278 #### test personality() and ADDR_NO_RANDOMIZE ####
2279 # Only works on modern Linux systems
2280 cat > $t <<EOT
2281 #include <sys/personality.h>
2282 int main() {
2283     int orig_persona = personality(0xffffffff);
2284     personality(orig_persona | ADDR_NO_RANDOMIZE);
2285     return 0;
2286 }
2287 EOT
2288 test_cxx "whether personality() and ADDR_NO_RANDOMIZE exist" "yes" "no" ""
2289 AC_DEFINE_UNQUOTED(CMK_HAS_ADDR_NO_RANDOMIZE, $pass, [whether personality() and ADDR_NO_RANDOMIZE exist])
2290
2291
2292 # enable/disable zlib
2293 AC_ARG_ENABLE([zlib],
2294             [AS_HELP_STRING([--enable-zlib],
2295               [enable zlib support])],
2296             [enable_zlib=$enableval],
2297             [enable_zlib=yes])
2298
2299 #### test if has zlib ####
2300 # bproc doesnot like -lz in any case
2301 if test -z "$CMK_BPROC" && test "$enable_zlib" = "yes"
2302 then
2303
2304 cat > $t <<EOT
2305 #include <zlib.h>
2306 int main() { 
2307   gzFile f = gzopen("/tmp/x","r");
2308   gzprintf(f, "test...\n");
2309   gzclose(f);
2310   return 0;
2311 }
2312 EOT
2313 test_link "whether has zlib" "yes" "no" "-lz"
2314 AC_DEFINE_UNQUOTED(CMK_USE_ZLIB, $pass, [whether has zlib])
2315 if test $pass -eq 1
2316 then 
2317         add_flag 'CMK_SYSLIBS="$CMK_SYSLIBS -lz"' "zlib"
2318 fi
2319
2320 fi
2321
2322 #### test if has elf.h ####
2323 cat > $t <<EOT
2324 #include <elf.h>
2325 typedef Elf32_Addr ELF_TYPE_Addr;
2326 int main() { 
2327 }
2328 EOT
2329 test_cxx "whether has elf.h " "yes" "no" ""
2330 AC_DEFINE_UNQUOTED([CMK_HAS_ELF_H], $pass, [whether has elf.h])
2331 if test $pass -eq 1
2332 then
2333         add_flag "CMK_HAS_ELF_H='1'" "elf.h"
2334 fi
2335
2336 #### test if has Multiprocessing.h for apple ####
2337 cat > $t <<EOT
2338 #include <Carbon/Carbon.h>
2339 #include <Multiprocessing.h>
2340 int main() {
2341   int a = MPProcessorsScheduled();
2342 }
2343 EOT
2344 test_cxx "whether has Multiprocessing.h for Apple " "yes" "no" ""
2345 AC_DEFINE_UNQUOTED([CMK_HAS_MULTIPROCESSING_H], $pass, [whether has Multiprocessing.h])
2346
2347 #### test if "ntohl" is available ####
2348 cat > $t <<EOT
2349 #if defined(_WIN32) || defined(__MINGW_H)
2350 #include <winsock.h>
2351 #else
2352 #include <stdint.h>
2353 #include <arpa/inet.h>
2354 #include <netinet/in.h>
2355 #endif
2356
2357 int main() {
2358   int i = 100;
2359   i = ntohl(i);
2360   return 0;
2361 }
2362 EOT
2363 test_cc "whether ntohl is available" "yes" "no" ""
2364 AC_DEFINE_UNQUOTED(CMK_HAS_NTOHL, $pass, [whether ntohl is available])
2365
2366 ### test for libjpeg ####
2367 cat > $t <<EOT
2368 #include <stdio.h>
2369 #include <stdlib.h>
2370 #include "jpeglib.h"
2371
2372 int main()
2373 {
2374   struct jpeg_compress_struct cinfo;
2375   jpeg_create_compress(&cinfo);
2376   return 0;
2377 }
2378 EOT
2379 test_link "whether has libjpeg" "yes" "no" "-ljpeg"
2380 AC_DEFINE_UNQUOTED(CMK_USE_LIBJPEG, $pass, [whether has libjpeg])
2381 if test $pass -eq 1
2382 then
2383         add_flag 'CMK_LIBJPEG="-ljpeg"' "libjpeg"
2384         add_make_flag 'CMK_LIBJPEG:=-ljpeg' 'libjpeg'
2385 fi
2386
2387 #### check if PAPI exists ####
2388 if test -n "$CMK_USE_PAPI"
2389 then
2390 cat > $t <<EOT
2391 #include <stdio.h>
2392 #include <papi.h>
2393                                                                                 
2394 int main() {
2395     if (PAPI_library_init(PAPI_VER_CURRENT) != PAPI_VER_CURRENT) return 1;
2396     return 0;
2397 }
2398 EOT
2399 test_link "whether PAPI exists" "yes" "no" "-lpapi"
2400 AC_DEFINE_UNQUOTED(CMK_HAS_COUNTER_PAPI, $pass, [whether PAPI exists])
2401 if test "$enable_tracing" = "no"
2402 then
2403         echo "Error: Cannot build papi version when tracing is disabled, build with --enable-tracing"
2404         test_finish 1
2405 elif test $fail -eq 1
2406 then
2407         echo "Error: Cannot find papi library"
2408         test_finish 1
2409 else
2410         add_flag 'CMK_LIBS="$CMK_LIBS -lpapi"' "papi"
2411 fi
2412 fi
2413
2414 #### test if Python headers are installed ####
2415 PYTHON_VERSION=`python -V 2>&1 | awk {'print $2'} | awk -F. {'print $1"."$2'}`
2416 cat > $t <<EOT
2417 #include "python${PYTHON_VERSION}/Python.h"
2418 #include "python${PYTHON_VERSION}/compile.h"
2419 #include "python${PYTHON_VERSION}/eval.h"
2420 #include "python${PYTHON_VERSION}/node.h"
2421
2422 int main() {
2423     Py_Initialize();
2424     PyEval_InitThreads();
2425     struct _node* programNode = PyParser_SimpleParseString("return 1\n",Py_file_input);
2426     PyCodeObject *program = PyNode_Compile(programNode, "");
2427 }
2428 EOT
2429 test_link "whether Python is installed" "yes" "no" "-lpython$PYTHON_VERSION -lpthread -lutil -ldl"
2430 AC_DEFINE_UNQUOTED(CMK_HAS_PYTHON, $pass, [whether Python is installed])
2431 AC_DEFINE_UNQUOTED(CMK_PYTHON_VERSION, ${PYTHON_VERSION}, [Python version])
2432 if test $pass -eq 1
2433 then
2434         add_flag "CMK_BUILD_PYTHON=$PYTHON_VERSION" "python"
2435         add_make_flag "CMK_BUILD_PYTHON:=$PYTHON_VERSION" 'python'
2436 fi
2437
2438 ## Cray specific test
2439 if test "$CMK_BUILD_CRAY" = "1"
2440 then
2441 #echo "Test for known incompatible compiler versions"
2442
2443  if test "$CRAY_CC_VERSION" = "8.1.4"
2444  then
2445         echo "CCE 8.1.4 produces incorrect Charm++ code"
2446         echo "Please use a newer version of the CCE compiler"
2447         echo "e.g. module load cce/8.1.7"
2448         test_finish 1
2449  fi
2450
2451 #### test if Cray node topology will work ####
2452 cat > $tc <<EOT
2453 #include <pmi.h>
2454
2455 int main() {
2456     int nid;
2457     PMI_Get_nid(0, &nid);
2458
2459     return 0;
2460 }
2461 EOT
2462 test_linkc "whether PMI_Get_nid exists" "yes" "no" "$CMK_CRAY_LIBS"
2463 AC_DEFINE_UNQUOTED(CMK_HAS_PMI_GET_NID, $pass, [whether PMI_Get_nid exists])
2464
2465 #### test if Cray mesh topology will work ####
2466 cat > $tc <<EOT
2467 #include <rca_lib.h>
2468
2469 int main() {
2470     rca_mesh_coord_t xyz;
2471     rca_get_meshcoord(0, &xyz);
2472
2473     return 0;
2474 }
2475 EOT
2476 test_linkc "whether Cray rca library is available" "yes" "no" "$CRAY_RCA_POST_LINK_OPTS -lrca"
2477 AC_DEFINE_UNQUOTED(CMK_HAS_RCALIB, $pass, [whether Cray rca library is available])
2478
2479 #### test if Cray mesh dimension query function will work ####
2480 cat > $tc <<EOT
2481 #include <rca_lib.h>
2482
2483 int main() {
2484     rca_mesh_coord_t xyz;
2485     rca_get_max_dimension(&xyz);
2486
2487     return 0;
2488 }
2489 EOT
2490 test_linkc "whether Cray rca_has get_max_dimension" "yes" "no" "$CRAY_RCA_POST_LINK_OPTS -lrca"
2491 AC_DEFINE_UNQUOTED(CMK_HAS_RCA_MAX_DIMENSION, $pass, [whether Cray rca has rca_get_max_dimension])
2492
2493 #### query Cray machine max NID if get_max_dimension not exist ####
2494
2495 if test $pass -eq 0
2496 then
2497 cmd=`which xtprocadmin 2>/dev/null`
2498 if test -n "$cmd"
2499 then
2500     #maxnid=`xtprocadmin  | tail -1  | awk '{print $1}'`
2501     # workaround for hopper
2502     (export SHELL=/bin/csh; xtprocadmin >& t.$$)
2503     maxnid=`cat t.$$  | tail -1  | awk '{print $1}'`
2504     /bin/rm -f t.$$
2505     AC_MSG_CHECKING(Cray machine maxnid)
2506     AC_MSG_RESULT("$maxnid")
2507     if test -n "$maxnid"
2508     then
2509     AC_DEFINE_UNQUOTED(CMK_CRAY_MAXNID, $maxnid, [Cray MAXNID])
2510     fi
2511 fi
2512 fi
2513
2514
2515
2516
2517 #### query Cray machine supports BANDWIDTH_INJECTION controls####
2518
2519 if test "$CMK_BUILD_MPI" = "1"
2520 then
2521 echo "BALANCED_INJECTION test disabled on MPI"
2522 elif test "$GNI_CRAYXC" = "1"
2523 then
2524 echo "BALANCED_INJECTION test disabled on Aries network"
2525 else
2526 cat > $tc <<EOT
2527 #include <stdint.h>
2528 #include <gni_pub.h>
2529
2530 int main() {
2531     gni_bi_desc_t gni_bi_desc;
2532     uint32_t gni_device_id = 0;
2533     gni_return_t gni_rc = GNI_GetBIConfig(gni_device_id, &gni_bi_desc);
2534     if (gni_rc == GNI_RC_SUCCESS) {
2535     }
2536     return 0;
2537 }
2538 EOT
2539 test_linkc "whether GNI_GetBIConfig exists" "yes" "no" "$CMK_CRAY_LIBS"
2540 AC_DEFINE_UNQUOTED(CMK_BALANCED_INJECTION_API, $pass, [whether Cray gni_pub has GNI_GetBIConfig])
2541 fi # end of BIConfig test
2542
2543
2544 fi  # end of Cray specific test
2545
2546 #### test if it can build shared library ####
2547 cat > $t <<EOT
2548 #include "stdlib.h"
2549 extern int foo();
2550 int foo1() { 
2551   void * t= malloc(2);
2552   foo();
2553   return 0;
2554 }
2555 EOT
2556 test_linkso "whether can build shared library" "yes" "no" ""
2557 if test $pass -eq 0
2558 then 
2559         add_flag 'CMK_NO_BUILD_SHARED="true"' "build-shared"
2560         add_make_flag 'CMK_NO_BUILD_SHARED:=true' 'build-shared'
2561         CMK_NO_BUILD_SHARED='true'
2562 else
2563         BUILD_SHARED=1
2564         if test "$BUILD_MPI" = "1"
2565         then
2566 cat > $t <<EOT
2567 #include "stdlib.h"
2568 #include "mpi.h"
2569 extern int foo();
2570 int foo(int argc, char ** argv) {
2571   void * t= malloc(2);
2572   foo();
2573   MPI_Init(&argc, &argv);
2574   return 0;
2575 }
2576 EOT
2577                 test_linkso "whether can build shared library with MPI" "yes" "no" ""
2578                 BUILD_SHARED=$pass
2579         fi
2580         if test $BUILD_SHARED -eq 0
2581         then
2582                 add_flag 'CMK_NO_BUILD_SHARED="true"' "build-shared"
2583                 add_make_flag 'CMK_NO_BUILD_SHARED:=true' 'build-shared'
2584                 CMK_NO_BUILD_SHARED='true'
2585         fi
2586 fi
2587
2588 #### test the version number of bproc ####
2589 if test -n "$CMK_BPROC"
2590 then
2591 cat > $t <<EOT
2592 #include <stdio.h>
2593 #include <sys/bproc.h>
2594 int main()
2595 {
2596   struct bproc_version_t vers;
2597   bproc_version(&vers);
2598   printf("%s\n", vers.version_string);
2599 }
2600 EOT
2601 test_link "whether bproc compiles" "yes" "no" "-lbproc"
2602 if test $pass -eq 1
2603 then 
2604 AC_MSG_CHECKING("bproc version")
2605 bproc_ver=`./testlink`
2606 if test x$bproc_ver = x
2607 then
2608 test_result 0 "bproc version" "ERROR" ""
2609 test_finish 1
2610 else
2611 test_result 0 "bproc version" "$bproc_ver" ""
2612 fi
2613 bproc_ver=`echo $bproc_ver | cut -d'.' -f1`
2614 AC_DEFINE_UNQUOTED(CMK_BPROC_VERSION, $bproc_ver, [bproc version])
2615 fi
2616 fi
2617
2618 #### test the if command sync exists ####
2619 AC_CHECK_PROG(SYNC, sync, sync )
2620 if test -n "$SYNC"
2621 then
2622 AC_DEFINE_UNQUOTED(CMK_HAS_SYNC, 1, [sync program])
2623 fi
2624
2625 ################## Fortran #########################
2626
2627 #echo "set F77 compiler as: $CMK_CF77"
2628 AC_MSG_CHECKING("F77 compiler as")
2629 AC_MSG_RESULT("$CMK_CF77")
2630
2631 AC_MSG_CHECKING("whether Fortran 77 compiler works")
2632 ### test fortran 77 compiler ###
2633 cat > conftest.f <<EOF
2634       SUBROUTINE FOO_foo
2635       END
2636 EOF
2637 $CMK_CF77 -c conftest.f > /dev/null 2> /dev/null
2638 if test ! -r conftest.o
2639 then
2640   AC_MSG_RESULT("no")
2641 else
2642   AC_MSG_RESULT("yes")
2643 fi
2644
2645 ### test fortran 90 compiler ###
2646 #echo "set F90 compiler as: $CMK_CF90"
2647 AC_MSG_CHECKING("F90 compiler as")
2648 AC_MSG_RESULT("$CMK_CF90")
2649
2650 AC_MSG_CHECKING("whether Fortran 90 compiler works")
2651 cat > conftest2.f90 <<EOF
2652       SUBROUTINE FOO_foo
2653       END
2654 EOF
2655 $CMK_CF90 -c conftest2.f90 > /dev/null 2> /dev/null
2656 if test ! -r conftest2.o
2657 then
2658   AC_MSG_RESULT("no")
2659 else
2660   AC_MSG_RESULT("yes")
2661   mv -f conftest2.o conftest.o
2662   USE_FORTRAN90=1
2663 fi
2664
2665 ### check fortran name mangling
2666 AC_MSG_CHECKING(subroutine name used by Fortran 90 compiler)
2667
2668 if test -r conftest.o
2669 then
2670   AC_CACHE_VAL(_cv_fortran_postfix,
2671
2672   NAME=`$CMK_NM conftest.o | grep "foo_foo__"`
2673   if test "$NAME" != ""
2674   then
2675     _cv_fortran_postfix=TWOSCORE
2676     AC_DEFINE_UNQUOTED(CMK_FORTRAN_USES_TWOSCORE, 1, [TWOSCORE])
2677   else
2678     NAME=`$CMK_NM conftest.o | grep "foo_foo_"`
2679     if test "$NAME" != ""
2680     then
2681       _cv_fortran_postfix=ONESCORE
2682       AC_DEFINE_UNQUOTED(CMK_FORTRAN_USES_ONESCORE, 1, [ONESCORE])
2683     else
2684       NAME=`$CMK_NM conftest.o | grep "foo_foo"`
2685       if test "$NAME" != ""
2686       then
2687         _cv_fortran_postfix=NOSCORE
2688         AC_DEFINE_UNQUOTED(CMK_FORTRAN_USES_NOSCORE, 1, [NOSCORE])
2689       else
2690         NAME=`$CMK_NM conftest.o | grep "FOO_FOO"`
2691         if test "$NAME" != ""
2692         then
2693           _cv_fortran_postfix=ALLCAPS
2694           AC_DEFINE_UNQUOTED(CMK_FORTRAN_USES_ALLCAPS, 1, [ALLCAPS])
2695         else
2696           echo "#################################################"
2697           echo "FORTRAN compiler generated name not supported yet"
2698           echo "#################################################"
2699         fi
2700       fi
2701     fi
2702   fi
2703   rm -f conftest.f conftest.o
2704   )
2705   AC_MSG_RESULT($_cv_fortran_postfix)
2706 else
2707   AC_MSG_RESULT("Fortran compiler not working")
2708 fi
2709
2710 ### check module name ###
2711
2712 if test "$USE_FORTRAN90" = 1
2713 then
2714   cat > conftest.f90 <<EOF
2715       MODULE testmod
2716         interface 
2717           function fpup_issizing(p)
2718           INTEGER :: p
2719           logical fpup_issizing
2720           end function
2721         end interface
2722       END MODULE
2723 EOF
2724   AC_MSG_CHECKING(Fortran 90 mod name is capital)
2725   $CMK_CF90 -c conftest.f90 > /dev/null 2> /dev/null
2726   name=`ls TESTMOD.* 2>/dev/null`
2727   if test -n "$name"
2728   then
2729         AC_MSG_RESULT("yes")
2730         add_flag 'CMK_MOD_NAME_ALLCAPS=1' "mod name capital"
2731   else
2732         AC_MSG_RESULT("no")
2733         name=`ls testmod.* 2>/dev/null`
2734   fi
2735   if test -n "$name"
2736   then
2737         AC_MSG_CHECKING(Fortran 90 mod name extension)
2738         ext=`echo $name | sed -e 's/^[[^.]]*\.//'`
2739         add_flag 'CMK_MOD_EXT="'$ext'"' "mod name extension"
2740         AC_MSG_RESULT("$ext")
2741         /bin/rm -f $name
2742   fi
2743   /bin/rm -f conftest.f90
2744 fi
2745
2746 ### test if the C++ linker succeeds with a Fortran entry point ##
2747
2748 cat > conftest.f90 <<EOF
2749       PROGRAM empty
2750       END PROGRAM
2751 EOF
2752 test_link_fortran_main() {
2753   AC_MSG_CHECKING("$1")
2754   echo "### $1" >> $charmout
2755   cat conftest.f90 >> $charmout
2756   echo $CMK_CF90 -c conftest.f90 -o test.o $4 >> $charmout
2757   $CMK_CF90 -c conftest.f90 -o test.o $4 > out 2>&1
2758   if test $? -ne 0
2759   then
2760     test_result 1 "$1" "$2" "$3"
2761   else
2762     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
2763     $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
2764     ret=$?
2765     test ! -x testlink && ret=1
2766     test_result $ret "$1" "$2" "$3"
2767   fi
2768   cat out >> $charmout
2769 }
2770 test_link_fortran_main "whether the C++ linker succeeds with a Fortran entry point" "yes" "no" ""
2771 /bin/rm -f conftest.f90 test.o testlink out
2772 if test $pass -eq 1
2773 then
2774   add_flag "CMK_CAN_LINK_FORTRAN='1'" "Fortran"
2775 fi
2776
2777 ### check for OpenMP availability ###
2778 cat > $tc <<EOT
2779 #include <stdio.h>
2780 #include <omp.h>
2781
2782 int main(void)
2783 {
2784   int iam = 0, np = 1;
2785
2786   #pragma omp parallel default(shared) private(iam, np)
2787   {
2788     np = omp_get_num_threads();
2789     iam = omp_get_thread_num();
2790     printf("Hello from thread %d of %d\n", iam, np);
2791   }
2792
2793   return 0;
2794 }
2795 EOT
2796 test_linkc "whether OpenMP is supported" "yes" "no" "$CMK_C_OPENMP"
2797 if test $pass -eq 1
2798 then
2799         add_flag "CMK_HAS_OPENMP='1'" "OpenMP"
2800 fi
2801
2802 ### check for Lustre FS availability ###
2803 cat > $tc <<EOT
2804 #include <stdio.h>
2805 #include <lustre/lustreapi.h>
2806 #include <lustre/lustre_user.h>
2807
2808 int main() {
2809   llapi_printf(LLAPI_MSG_NORMAL, "Lustre FS is available");
2810   return 0;
2811 }
2812 EOT
2813 test_linkc "whether has lustre fs" "yes" "no" "-llustreapi"
2814 AC_DEFINE_UNQUOTED(CMK_HAS_LUSTREFS, $pass, [whether has lustrefs])
2815 if test $pass -eq 1
2816 then
2817   add_make_flag 'CMK_LUSTREAPI:=-llustreapi' "lustreapi"
2818 else
2819   add_make_flag 'CMK_LUSTREAPI:=' "lustreapi"
2820 fi
2821
2822
2823 # for hwloc
2824 eval "`./charmc -print-building-blocks $OPTS`"
2825 export CC="$(get_full_command_name "$CMK_SEQ_CC")"
2826 export CXX="$(get_full_command_name "$CMK_SEQ_CXX")"
2827 export CC_FOR_BUILD="$(get_full_command_name "$CMK_NATIVE_CC")"
2828 AC_SUBST(CC_FOR_BUILD)
2829 export HWLOC_FLAGS="$CHARM_CC_FLAGS"
2830 export CFLAGS="$CMK_SEQ_CC_FLAGS"
2831 export AR="$(get_full_command_name "${CMK_SEQ_AR%% *}")"
2832 enable_embedded_mode='yes'
2833 enable_static='yes'
2834 if test "$CMK_NO_BUILD_SHARED" = 'false'
2835 then
2836   enable_shared='yes'
2837   export am_libhwloc_embedded_la_rpath="-rpath $CHARMLIBSO"
2838 else
2839   enable_shared='no'
2840   export am_libhwloc_embedded_la_rpath=''
2841 fi
2842 AC_SUBST(am_libhwloc_embedded_la_rpath)
2843 enable_libnuma='no'
2844 enable_pci='no'
2845 enable_libudev='no'
2846 enable_libxml2='no'
2847 enable_visibility='no'
2848 enable_nvml='no'
2849 . hwloc/VERSION
2850 export libhwloc_so_version
2851 AC_SUBST(libhwloc_so_version)
2852
2853 echo "Configuring hwloc:"
2854 AC_CONFIG_AUX_DIR(hwloc/config)
2855 AC_CANONICAL_TARGET
2856 AC_USE_SYSTEM_EXTENSIONS
2857 LT_INIT
2858
2859 AM_INIT_AUTOMAKE([no-define])
2860
2861 AC_CONFIG_MACRO_DIR(hwloc/config)
2862 HWLOC_SET_SYMBOL_PREFIX([cmi_])
2863 HWLOC_SETUP_CORE([hwloc], [happy=yes], [happy=no])
2864 HWLOC_DO_AM_CONDITIONALS
2865 add_flag 'CMK_HWLOC_LIBS="-lhwloc_embedded '"$HWLOC_EMBEDDED_LIBS"'"' "hwloc"
2866
2867 AC_OUTPUT