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