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