Integrated the memory affinity settings into charm++
[charm.git] / src / scripts / configure.in
1
2 AC_INIT(./Makefile)
3
4 AC_CONFIG_HEADER(conv-autoconfig.h)
5
6 CHARMINC="."
7 test -r ./conv-config.sh && . ./conv-config.sh
8
9 #keep it a decimal
10 VERSION=60301
11 echo $VERSION > ../include/VERSION
12 AC_DEFINE_UNQUOTED([CHARM_VERSION], $VERSION, [Charm++ version number])
13
14 charmout="charmconfig.out"
15 /bin/rm -rf $charmout
16
17 Echo() {
18         echo $* 
19         echo $* >> $charmout
20 }
21
22 # enable/disable error checking
23 AC_ARG_ENABLE([error-checking],
24             [AS_HELP_STRING([--enable-error-checking],
25               [enable error checking])], ,
26             [enable_error_checking=yes])
27
28 if test "$enable_error_checking" = "no"
29 then
30   Echo "Error checking is disabled" 
31   AC_DEFINE_UNQUOTED(CMK_ERROR_CHECKING, 0, [disable error checking])
32 else
33   AC_DEFINE_UNQUOTED(CMK_ERROR_CHECKING, 1, [enable error checking])
34 fi
35
36 # check enable/disable
37 AC_ARG_ENABLE([tracing],
38             [AS_HELP_STRING([--enable-tracing],
39               [enable tracing modules])], ,
40             [enable_tracing=yes])
41
42 if test "$enable_tracing" = "no"
43 then
44   Echo "Charm tracing is disabled"
45   AC_DEFINE_UNQUOTED(CMK_TRACE_ENABLED, 0, [disable tracing])
46 else
47   AC_DEFINE_UNQUOTED(CMK_TRACE_ENABLED, 1, [disable tracing])
48 fi
49
50 AC_ARG_ENABLE([charmdebug],
51             [AS_HELP_STRING([--enable-charmdebug],
52               [enable charmDebug])], ,
53             [enable_charmdebug=yes])
54
55 if test "$enable_charmdebug" = "no"
56 then
57   Echo "CharmDebug is disabled" 
58   AC_DEFINE_UNQUOTED(CMK_CHARMDEBUG, 0, [disable charmdebug])
59 else
60   AC_DEFINE_UNQUOTED(CMK_CHARMDEBUG, 1, [enable charmdebug])
61 fi
62
63 AC_ARG_ENABLE([replay],
64             [AS_HELP_STRING([--enable-replay],
65               [enable record/replay])],
66             [enable_replay=$enableval],
67             [enable_replay=yes])
68
69 if test "$enable_replay" = "no"
70 then
71   Echo "Charm record/replay is disabled"
72   AC_DEFINE_UNQUOTED(CMK_REPLAYSYSTEM, 0, [disable replay])
73 fi
74
75 AC_ARG_WITH([numa],
76             [AS_HELP_STRING([--with-numa],
77               [support memory affinity with NUMA])],
78             [],
79             [with_numa=no])
80
81 WITH_NUMA=no
82 if test "$with_numa" = "yes"
83 then
84   Echo "Charm NUMA support is builtin"
85   WITH_NUMA=yes
86 fi
87           
88
89 #
90 AC_MSG_CHECKING(machine name)
91 version=`pwd | awk -F/ '{print $(NF-1)}'`
92 base_version=`cat .vdir`
93 AC_DEFINE_UNQUOTED(CMK_MACHINE_NAME, "$version",[machine name])
94 AC_MSG_RESULT($version)
95 AC_SUBST(base_version)
96
97 t="test.cpp"
98 tc="test.c"
99
100 # test result passed in $1
101 # If the test suceeded, print $3 and set "pass"/clear "fail"
102 # If the test failed, print $2 and clear "pass"/set "fail"
103 test_result() {
104         if test $1 -eq 0
105         then
106                 AC_MSG_RESULT("$3")
107                 pass="1"
108                 fail="0"
109         else
110                 AC_MSG_RESULT("$4")
111                 pass="0"
112                 fail="1"
113 # For debugging the configure script, just "export autoconf_debug=1"
114 #  to get this verbose data on any failed tests:
115                 if test ! -z "$autoconf_debug"
116                 then
117                         echo "------- test script for $2 failed:"
118                         cat out
119                         echo "------- the test program was:"
120                         cat $t
121                         echo "-------"
122                 fi
123         fi
124 }
125
126 # Test: tries to compile C file $t (described by $1).
127 #  If successful, prints $2 and sets $pass/clears $fail
128 #  If failure, prints $3 and sets $pass/clears $fail
129 #  additional arguments to c++ compiler are passed as $4
130 test_cc() {
131         AC_MSG_CHECKING("$1")
132         echo "### $1" >> $charmout
133         cat $tc >> $charmout
134         echo $CMK_CC -I../include -I. $CMK_LIBDIR $CMK_INCDIR $OPTS_CC $OPTS_LD -c $tc -o test.o $4 >> $charmout
135         $CMK_CC -I../include -I. $CMK_LIBDIR $CMK_INCDIR $OPTS_CC $OPTS_LD -c $tc -o test.o $4 > out 2>&1
136         test_result $? "$1" "$2" "$3"
137         strictpass=$pass
138         strictfail=$fail
139         if test $pass -eq 1
140         then 
141           if cat out | grep -i "warn" > /dev/null 2>&1
142           then 
143             strictpass="0" && strictfail="1"
144           fi
145         fi
146         cat out >> $charmout
147         /bin/rm -f out
148 }
149
150 # Test: tries to compile C++ file $t (described by $1).
151 #  If successful, prints $2 and sets $pass/clears $fail
152 #  If failure, prints $3 and sets $pass/clears $fail
153 #  additional arguments to c++ compiler are passed as $4
154 test_cxx() {
155         AC_MSG_CHECKING("$1")
156         echo "### $1" >> $charmout
157         cat $t >> $charmout
158         echo $CMK_CXX -I../include -I. $CMK_LIBDIR $CMK_INCDIR $OPTS_CXX $OPTS_LD -c $t -o test.o $4 >> $charmout
159         $CMK_CXX -I../include -I. $CMK_LIBDIR $CMK_INCDIR $OPTS_CXX $OPTS_LD -c $t -o test.o $4 > out 2>&1
160         test_result $? "$1" "$2" "$3"
161         strictpass=$pass
162         strictfail=$fail
163         if test $pass -eq 1
164         then 
165           if cat out | grep -i "warn" > /dev/null 2>&1
166           then 
167             strictpass="0" && strictfail="1"
168           fi
169         fi
170         cat out >> $charmout
171         /bin/rm -f out
172 }
173
174 # Testlink: tries to compile and link a C++ file $t (described by $1).
175 #  If successful, prints $2 and sets $pass/clears $fail
176 #  If failure, prints $3 and sets $pass/clears $fail
177 #  additional arguments to c++ compiler are passed as $4
178 test_link() {
179         AC_MSG_CHECKING("$1")
180         echo "### $1" >> $charmout
181         cat $t >> $charmout
182         echo $CMK_CXX -I../include -I. $CMK_INCDIR $OPTS_CXX -c $t -o test.o $4 >> $charmout
183         $CMK_CXX -I../include -I. $CMK_INCDIR $OPTS_CXX -c $t -o test.o $4 > out 2>&1
184         if test $? -ne 0
185         then
186           test_result 1 "$1" "$2" "$3"
187         else
188           echo $CMK_LDXX -o testlink test.o $CMK_LIBDIR $OPTS_LD $CMK_SYSLIBS $4 >> $charmout
189           $CMK_LDXX -o testlink test.o $CMK_LIBDIR $OPTS_LD $CMK_SYSLIBS $4 >> out 2>&1
190           ret=$?
191           test ! -x testlink && ret=1
192           test_result $ret "$1" "$2" "$3"
193         fi
194         strictpass=$pass
195         strictfail=$fail
196         if test $pass -eq 1
197         then 
198           if cat out | grep -i "warn" > /dev/null 2>&1
199           then 
200             strictpass="0" && strictfail="1"
201           fi
202         fi
203         cat out >> $charmout
204         /bin/rm -f out
205 }
206
207 # Testlinkc: tries to compile and link a C file $t (described by $1).
208 #  If successful, prints $2 and sets $pass/clears $fail
209 #  If failure, prints $3 and sets $pass/clears $fail
210 #  additional arguments to c++ compiler are passed as $4
211 test_linkc() {
212         AC_MSG_CHECKING("$1")
213         echo "### $1" >> $charmout
214         cat $tc >> $charmout
215         echo $CMK_CC -I../include -I. $CMK_INCDIR $OPTS_CC -c $tc -o test.o $4 >> $charmout
216         $CMK_CC -I../include -I. $CMK_INCDIR $OPTS_CC -c $tc -o test.o $4 > out 2>&1
217         if test $? -ne 0
218         then
219           test_result 1 "$1" "$2" "$3"
220         else
221           echo $CMK_LD -o testlink test.o $CMK_LIBDIR $OPTS_LD $CMK_SYSLIBS $4 >> $charmout
222           $CMK_LD -o testlink test.o $CMK_LIBDIR $OPTS_LD $CMK_SYSLIBS $4 >> out 2>&1
223           test_result $? "$1" "$2" "$3"
224         fi
225         strictpass=$pass
226         strictfail=$fail
227         if test $pass -eq 1
228         then 
229           if cat out | grep -i "warn" > /dev/null 2>&1
230           then 
231             strictpass="0" && strictfail="1"
232           fi
233         fi
234         cat out >> $charmout
235         /bin/rm -f out
236 }
237
238 # test_linkso $1 $2 $3 $4, where
239 # $1: debug msg
240 # $2: yes msg
241 # $3: no msg
242 # $4: extra link option
243 test_linkso() {
244         AC_MSG_CHECKING("$1")
245         echo $1 >> $charmout
246         cat $t >> $charmout
247         echo $CMK_CXX -I../include -I. $CMK_INCDIR $OPTS_CXX -c $t -o test.o $4 >> $charmout
248         $CMK_CXX -I../include -I. $CMK_INCDIR $OPTS_CXX -c $t -o test.o $4 > out 2>&1
249         if test $? = 1
250         then
251           test_result 1 "$1" "$2" "$3"
252         else
253           echo $CMK_LD -I../include -I. $CMK_LIBDIR $OPTS_LD $CMK_LD_SHARED test.o -o testlink.$CMK_SHARED_SUF $4 >> $charmout
254           $CMK_LD -I../include -I. $CMK_LIBDIR $OPTS_LD $CMK_LD_SHARED test.o -o testlink.$CMK_SHARED_SUF $4 > out 2>&1
255           test_result $? "$1" "$2" "$3"
256         fi
257         cat out >> $charmout
258         /bin/rm -f out testlink.$CMK_SHARED_SUF
259 }
260
261 # add into conv-mach-opt.sh
262 # add_flag $1 $2
263 # $2 is description
264 add_flag() {
265         key=`echo $1 | cut -d'=' -f1`
266         last=`grep $key ../include/conv-mach-opt.sh 2>/dev/null | tail -1`
267         skip=0
268         if test -n "$last" -a  "$last" = "$1" 
269         then
270           skip=1
271         fi
272         if test $skip = 0
273         then
274           cat >> ../include/conv-mach-opt.sh << EOT
275
276 # Option added by configure script's $2 section
277 $1
278
279 EOT
280         fi
281 }
282
283 test_finish() {
284         rm -f $t $tc testlink test.o    > /dev/null 2>&1
285         /bin/rm -f out
286         exit $1
287 }
288
289 # detect certain architectures
290 if cat /proc/cpuinfo 2>/dev/null | grep 'POWER7'  > /dev/null
291 then
292   AC_DEFINE_UNQUOTED(CMK_POWER7, 1, [whether is power7])
293 fi
294
295 # try to decide the version of glibc
296 get_glibc_version() {
297 t=test.c
298 cat > $t <<EOT
299 #include <stdio.h>
300 #include <gnu/libc-version.h>
301 int main (void) { puts (gnu_get_libc_version ()); return 0; }
302 EOT
303 gcc -o gver test.c
304 GLIBCVERSION=`./gver`
305 /bin/rm -f $t gver
306 }
307
308 cat > $t <<EOT
309 #include <stdio.h>
310 void foo(void) {
311         printf("Hello, world!\n");
312 }
313 EOT
314 #echo "set C++ compiler as: $CMK_CXX $OPTS_CXX $OPTS"
315 AC_MSG_CHECKING("C++ compiler as")
316 AC_MSG_RESULT("$CMK_CXX $OPTS_CXX $OPTS")
317 test_cxx "whether C++ compiler works" "ok" "no" ""
318 if test $fail -eq 1
319 then
320         echo "Cannot compile C++ programs with $CMK_CXX"
321         echo " (check your charm++ version)"
322         test_finish 1
323 fi
324
325 cat > $t <<EOT
326 #include <stdio.h>
327 int main() {
328         printf("Hello, world!\n");
329         return 0;
330 }
331 EOT
332 #echo "set C++ linker as: $CMK_LDXX $OPTS_LDXX"
333 AC_MSG_CHECKING("C++ linker as")
334 AC_MSG_RESULT("$CMK_LDXX $OPTS_LDXX")
335 test_link "whether linker works" "ok" "no" ""
336 if test $fail -eq 1
337 then
338         echo "Cannot link C++ programs with $CMK_LDXX"
339         echo " (check your charm++ version)"
340         test_finish 1
341 fi
342
343 if test "$base_version" = "net-linux" 
344 then
345   test_link "whether linker accept --allow-multiple-definition" "ok" "no" "-Wl,--allow-multiple-definition"
346   if test $pass -eq 1
347   then
348         add_flag CMK_LDXX='"$CMK_LDXX -Wl,--allow-multiple-definition"' "net-linux linker"
349   fi
350 fi
351
352 # Perform the tests
353
354 #### Check if compiler if 64 bit ####
355 cat > $t <<EOT
356 #include <stdio.h>
357
358 int foo()
359 {
360 int x[[sizeof(void *) - 7]]={0};
361 return x[[0]];
362 }
363 EOT
364 test_cxx "whether compiler is 64bit" "yes" "no" ""
365 AC_DEFINE_UNQUOTED(CMK_SIZET_64BIT, $strictpass, [whether size_t 64bit])
366
367
368 #### check strings.h ####
369 cat > $t <<EOT
370 #include <strings.h>
371 int main() { 
372   char str[[8]];
373   bzero(str, 8);
374   return 0;
375 }
376 EOT
377 test_cxx "whether has strings.h " "yes" "no" ""
378 AC_DEFINE_UNQUOTED(CMK_HAS_STRINGS_H, $pass, [whether has strings.h])
379
380 #### test if has values.h ####
381 cat > $t <<EOT
382 #include <values.h>
383 int main() { 
384   double d = MAXDOUBLE;
385   return 0;
386 }
387 EOT
388 test_cxx "whether has values.h " "yes" "no" ""
389 AC_DEFINE_UNQUOTED(CMK_HAS_VALUES_H, $pass, [whether has values.h])
390
391 #### test if has stdint.h ####
392 cat > $t <<EOT
393 #include <stdint.h>
394 int main() { 
395   return 0;
396 }
397 EOT
398 test_cxx "whether has stdint.h " "yes" "no" ""
399 AC_DEFINE_UNQUOTED(CMK_HAS_STDINT_H, $pass, [whether has stdint.h])
400
401 #### test if has malloc.h ####
402 cat > $t <<EOT
403 #include <malloc.h>
404 int main() { 
405   return 0;
406 }
407 EOT
408 test_cxx "whether has malloc.h " "yes" "no" ""
409 AC_DEFINE_UNQUOTED(CMK_HAS_MALLOC_H, $pass, [whether has malloc.h])
410
411 #### test if has alloca.h ####
412 cat > $t <<EOT
413 #include <alloca.h>
414 int main() {
415   double *s=(double *)alloca(sizeof(double));
416   *s=1.0;
417   return 0;
418 }
419 EOT
420 test_cxx "whether has alloca.h " "yes" "no" ""
421 AC_DEFINE_UNQUOTED(CMK_HAS_ALLOCA_H, $pass, [whether has alloca.h])
422
423 #### test if has regex.h ####
424 cat > $t <<EOT
425 #include <regex.h>
426 int main() {
427   regex_t re;
428   regcomp(&re, ".*MOD.*", REG_EXTENDED|REG_NOSUB);
429   return 0;
430 }
431 EOT
432 test_cxx "whether has regex.h " "yes" "no" ""
433 AC_DEFINE_UNQUOTED(CMK_HAS_REGEX_H, $pass, [whether has regex.h])
434
435 #### Check bool ####
436 cat > $t <<EOT
437 #include <stdlib.h>
438 bool foo(void) { return true; }
439 EOT
440 test_cxx "whether C++ bool works" "ok" "no" ""
441 AC_DEFINE_UNQUOTED(CMK_BOOL_DEFINED, $pass, [whether C++ bool works])
442
443 #### Check long long ####
444 cat > $t <<EOT
445 #include <stdlib.h>
446 long long foo(void) { return 17; }
447 EOT
448 test_cxx "whether long long works" "ok" "no" ""
449 AC_DEFINE_UNQUOTED(CMK_LONG_LONG_DEFINED, $pass, [whether long long works])
450
451 #### Check __int64 ####
452 cat > $t <<EOT
453 #include <stdlib.h>
454 __int64 foo(void) { return 17; }
455 EOT
456 test_cxx "whether __int64 works" "ok" "no" ""
457 AC_DEFINE_UNQUOTED([CMK___int64_DEFINED], $pass, [whether __int64 works])
458
459 #### Check long double ####
460 cat > $t <<EOT
461 #include <stdlib.h>
462 long double foo(void) { return 17.0; }
463 EOT
464 test_cxx "whether long double works" "ok" "no" ""
465 AC_DEFINE_UNQUOTED(CMK_LONG_DOUBLE_DEFINED, $strictpass, [whether long double works])
466
467 #### Check ucontext and FPU pointer ####
468 cat > $t <<EOT
469 #include <ucontext.h>
470 struct _libc_fpstate   fpstate;
471 fpregset_t *fp;
472 EOT
473 test_cxx "whether ucontext has FPU pointer" "yes" "no" ""
474 AC_DEFINE_UNQUOTED(CMK_CONTEXT_FPU_POINTER, $pass, [whether ucontext has pointer])
475
476 if test $pass -eq 1
477 then
478 cat > $t <<EOT
479 #include <ucontext.h>
480
481 int main()
482 {
483   ucontext_t context;
484   context.uc_mcontext.uc_regs = 0;
485 }
486 EOT
487 test_cxx "whether ucontext uses uc_regs" "yes" "no" ""
488 AC_DEFINE_UNQUOTED(CMK_CONTEXT_FPU_POINTER_UCREGS, $pass, [whether ucontext uses uc_regs union])
489 fi
490
491 cat > $t <<EOT
492 #include <ucontext.h>
493 vrregset_t *v_regs;
494 ucontext_t  uc;
495
496 void foo()
497 {
498   vrregset_t *ptr = uc.uc_mcontext.v_regs;
499 }
500 EOT
501 test_cxx "whether ucontext has pointer (v_regs) of vector type" "yes" "no" ""
502 AC_DEFINE_UNQUOTED(CMK_CONTEXT_V_REGS, $pass, [whether ucontext has pointer (v_regs) of vector type])
503
504 ###################### C++ Compiler Features #####################
505
506 #### check C inline ####
507 cat > $tc <<EOT
508 inline static int foo()
509 {
510   return 1;
511 }
512 EOT
513 test_cc "whether inline works in C" "yes" "no" ""
514 AC_DEFINE_UNQUOTED(CMK_C_INLINE, $strictpass, [whether C inline works in C])
515
516 #### check explicit ####
517 cat > $t <<EOT
518 #include <stdlib.h>
519 class er {
520  protected:
521    explicit er(unsigned int inType) {};
522 };
523 EOT
524 test_cxx "whether C++ class explicit keyword works" "ok" "no" ""
525 AC_DEFINE_UNQUOTED(CMK_EXPLICIT, $pass, [whether C++ class explicit keyword works])
526
527 #### check if signed char is same as char ####
528 cat > $t <<EOT
529 #include <stdlib.h>
530 class er {
531  protected:
532    void operator()(char &v,const char *desc=NULL) {};
533    void operator()(signed char &v,const char *desc=NULL) {};
534 };
535 EOT
536 test_cxx "whether C++ signed char and char differ" "yes" "no" ""
537 AC_DEFINE_UNQUOTED(CMK_SIGNEDCHAR_DIFF_CHAR, $pass, [whether C++ signed char and char differ])
538
539 #### check if C++ casts work ####
540 cat > $t <<EOT
541 int foo(float *t) {return *reinterpret_cast<int *>(t);}
542 EOT
543 test_cxx "whether C++ *_casts<> work" "ok" "no" ""
544 AC_DEFINE_UNQUOTED(CMK_CPP_CAST_LEGAL, $pass, [C++ *_casts<> work])
545 AC_DEFINE_UNQUOTED(CMK_CPP_CAST_ILLEGAL, $fail, [C++ *_casts<> does not work])
546
547
548 ### check if varsize array on stack ####
549 cat > $t <<EOT
550 #include <stdio.h>
551 void foo()
552 {
553   int size=10;
554   char arr[size];
555 }
556
557 EOT
558 test_cxx "whether C++ allows declaration of varsize array" "yes" "no" ""
559 AC_DEFINE_UNQUOTED(CMK_DECLARE_VARSIZE_ARRAY, $pass, [whether C++ allows declaration of variable sized array])
560
561 ##### check if the stl headers use .h #####
562 cat > $t <<EOT
563 #include <iostream>
564 void foo(void) { std::cout<<"Hello, world"<<std::endl; }
565 EOT
566 test_cxx "whether including STL <foo> works" "ok" "no" ""
567 AC_DEFINE_UNQUOTED(CMK_STL_USE_DOT_H, $fail, [including STL <foo> does not works])
568 AC_DEFINE_UNQUOTED(CMK_STL_DONT_USE_DOT_H, $pass, [including STL <foo> works])
569
570 #### check if std::vector works ######
571 cat > $t <<EOT
572 #include <vector>
573
574 int foo(void) {
575   std::vector<int> v;      
576   v.push_back(2); v.push_back(3);
577   std::vector<int>::iterator it=v.begin();
578   it++;
579   return *it;
580 }
581 EOT
582 test_cxx "whether the std:: names for STL work" "ok" "no" ""
583 AC_DEFINE_UNQUOTED(CMK_USE_STL, $pass, [whether the std:: names for STL work])
584
585 #### check if namespaces can be defined #####
586 cat > $t <<EOT
587 namespace foo {
588         int x;
589 }
590 EOT
591 test_cxx "whether namespaces work" "ok" "no" ""
592 AC_DEFINE_UNQUOTED(CMK_NAMESPACES_BROKEN, $fail, [whether namespaces work])
593
594
595 #### check if typeinfo exists and works #####
596 cat > $t <<EOT
597 #include <typeinfo>
598 const char *foo(void) {
599         int x;
600         return typeid(x).name();
601 }
602 EOT
603 test_cxx "whether typeinfo/typeid works" "ok" "no" ""
604 AC_DEFINE_UNQUOTED(CMK_HAS_TYPEINFO, $pass, [whether typeinfo/typeid works])
605
606 #### check if iterator_traits is defined #####
607 cat > $t <<EOT
608 #include <iterator>
609
610 template <typename T> // T models Input Iterator
611 typename std::iterator_traits<T>::value_type accumulate(T first, T last)
612 {
613       typename std::iterator_traits<T>::value_type result = 0;
614       while(first != last)
615             result += *first++;
616       return result;
617 }
618 EOT
619 test_cxx "whether std::iterator_traits is defined" "ok" "no" ""
620 AC_DEFINE_UNQUOTED(CMK_HAS_ITERATOR_TRAITS, $pass, [whether iterator_traits works])
621
622 #### check if std::distance is defined #####
623 cat > $t <<EOT
624 #include <vector>
625 #include <iterator>
626
627 int foo()
628 {
629   std::vector<int> tree;
630   return std::distance(tree.begin(), tree.end());
631 }
632 EOT
633 test_cxx "whether std::distance is defined" "ok" "no" ""
634 AC_DEFINE_UNQUOTED(CMK_HAS_STD_DISTANCE, $pass, [whether std::distance works])
635
636
637 #### test if we can have multiple delete like this ####
638 cat > $t <<EOT
639 class foo {
640 public:
641   void operator delete(void*p){};
642   void operator delete(void*p,int*){};
643 };
644 EOT
645 test_cxx "whether operator delete can be overloaded in same class" "ok" "no" ""
646 AC_DEFINE_UNQUOTED(CMK_MULTIPLE_DELETE, $strictpass, [whether operator delete can be overloaded in same class])
647
648
649 #### test if we can use gcc x86 assembly like this ####
650 cat > $t <<EOT
651 double foo(void)
652 {
653   unsigned long long int v;
654   int *lo=0+(int *)&v;
655   int *hi=1+(int *)&v;
656   __asm__ __volatile__(
657       "rdtsc; movl %%edx,%0; movl %%eax,%1"
658       : /* output  */ "=m" (*hi), "=m" (*lo)
659       : /* input */
660       : /* trashes */ "%edx", "%eax"
661   );
662   return v;
663 }
664 EOT
665 test_cxx "whether GCC x86 assembly works" "yes" "no" ""
666 AC_DEFINE_UNQUOTED(CMK_GCC_X86_ASM, $strictpass, [Allows gcc x86 assembly.])
667
668 #### test if we can use gcc x86 assembly like this ####
669 if test $strictpass = 1
670 then
671 cat > $t <<EOT
672 int foo(void)
673 {
674   int x;
675   asm("lock incl %0" :: "m" (x));
676   asm("lock decl %0" :: "m" (x));
677   return x;
678 }
679 EOT
680 test_cxx "whether GCC x86 assembly for atomic increment works" "yes" "no" ""
681 AC_DEFINE_UNQUOTED(CMK_GCC_X86_ASM_ATOMICINCREMENT, $strictpass, [Allows gcc x86 assembly for atomic increment.])
682 fi
683
684 #### test if we can use gcc IA64 assembly like this ####
685 cat > $t <<EOT
686 double foo(void)
687 {
688         unsigned long long int x;
689         __asm__ __volatile__("mov %0=ar.itc" : "=r"(x) :: "memory");
690         return x;
691 }
692 EOT
693 test_cxx "whether GCC IA64 assembly works" "yes" "no" ""
694 AC_DEFINE_UNQUOTED(CMK_GCC_IA64_ASM, $strictpass, [Allows gcc IA64 assembly.])
695
696
697 #### test if we can use PPC assembly like this ####
698 cat > $t <<EOT
699 double foo(void)
700 {
701         unsigned long long int x;
702         asm volatile("eieio" ::: "memory");
703         return x;
704 }
705 EOT
706 test_cxx "whether PPC assembly works" "yes" "no" ""
707 AC_DEFINE_UNQUOTED(CMK_PPC_ASM, $strictpass, [Allows PPC assembly.])
708
709
710
711 #### test if we can use __thread ####
712 cat > $t <<EOT
713 __thread unsigned long long int x;
714 static __thread  int y;
715 void foo(void)
716 {
717         x = 1;
718         y = 1;
719 }
720 EOT
721 test_cxx "whether __thread (Thread Local Storage) is supported" "yes" "no" ""
722 AC_DEFINE_UNQUOTED(CMK_TLS_THREAD, $strictpass, [Allows __thread.])
723
724 #### test if we can build MPI ####
725 if test "$CMK_BUILD_MPI" = 1
726 then
727
728 cat > $t <<EOT
729 #include "mpi.h"
730 int main(int argc, char **argv)
731 {
732   MPI_Init(&argc, &argv);
733 }
734 EOT
735 mv -f ../include/mpi.h ../include/mpi.h.bak 2>/dev/null
736 test_cxx "whether build on MPI" "yes" "no" ""
737 AC_DEFINE_UNQUOTED(CMK_BUILD_ON_MPI, $strictpass, [build MPI.])
738 BUILD_MPI=$strictpass
739
740 if test $BUILD_MPI -eq 0
741 then
742   echo "Error: Can not compile a MPI program"
743   exit 1
744 fi
745
746 if test $BUILD_MPI -eq 1
747 then
748   test_link "whether need to specify MPI library" "no" "yes" ""
749   if test $pass -ne 1
750   then
751     if test -z "$CMK_MPI_LIB"
752     then
753       test_link "whether -lmpich" "ok" "no" "-lmpich"
754       if test $pass -eq 1
755       then
756         add_flag CMK_SYSLIBS='"$CMK_SYSLIBS -lmpich"' "mpi lib"
757       else
758         test_link "whether -lmpi" "ok" "no" "-lmpi"
759         if test $pass -eq 1
760         then
761                 add_flag CMK_SYSLIBS='"$CMK_SYSLIBS -lmpi"' "mpi lib"
762         else
763                 echo "Error: can not find mpi library"
764                 exit 1
765         fi
766       fi
767     else
768       add_flag CMK_SYSLIBS='"$CMK_SYSLIBS $CMK_MPI_LIB"' "mpi lib"
769     fi
770   fi
771 fi
772
773 if test "$BUILD_MPI" = "1"
774 then
775 cat > $t <<EOT
776 #include "mpi.h"
777 int main(int argc, char **argv)
778 {
779   int thread_level, provided;
780   thread_level = MPI_THREAD_FUNNELED;
781   MPI_Init_thread(&argc, &argv, thread_level, &provided);
782 }
783 EOT
784 test_cxx "whether MPI_Init_thread is supported" "yes" "no" ""
785 AC_DEFINE_UNQUOTED(CMK_MPI_INIT_THREAD, $strictpass, [Allows MPI_Init_thread.])
786 fi
787 mv -f ../include/mpi.h.bak ../include/mpi.h 2>/dev/null
788
789 fi
790
791 ################### Syscalls and Libraries ###################
792
793 #### test for log2 ###
794 cat > $t <<EOT
795 #include <math.h>
796 int main() {
797   int i = log2(10);
798   return 0;
799 }
800 EOT
801 test_link "whether has log2" "yes" "no" ""
802 AC_DEFINE_UNQUOTED(CMK_HAS_LOG2, $pass, [whether has log2])
803
804 #### test for sqrtf ###
805 cat > $t <<EOT
806 #include <math.h>
807 int main() {
808   float i = sqrtf((float)10.0);
809   return 0;
810 }
811 EOT
812 test_link "whether has sqrtf" "yes" "no" ""
813 AC_DEFINE_UNQUOTED(CMK_HAS_SQRTF, $pass, [whether has sqrtf])
814
815 #### test for fabsf ###
816 cat > $t <<EOT
817 #include <math.h>
818 int main() {
819   float i = fabsf((float)10.0);
820   return 0;
821 }
822 EOT
823 test_link "whether has fabsf" "yes" "no" ""
824 AC_DEFINE_UNQUOTED(CMK_HAS_FABSF, $pass, [whether has fabsf])
825
826 #### test for mkstemp ###
827 cat > $t <<EOT
828 #include <stdlib.h>
829 #include <string.h>
830 int main() {
831   char fname[[128]];
832   strcpy(fname, "/tmp/fdXXX.XXX");
833   mkstemp(fname);
834   return 0;
835 }
836 EOT
837 test_link "whether has mkstemp" "yes" "no" ""
838 AC_DEFINE_UNQUOTED(CMK_USE_MKSTEMP, $pass, [whether has mkstemp])
839
840 #### test for system ###
841 cat > $t <<EOT
842 #include <stdlib.h>
843 int main() {
844   system("/bin/ls");
845   return 0;
846 }
847 EOT
848 test_link "whether has system" "yes" "no" ""
849 AC_DEFINE_UNQUOTED(CMK_HAS_SYSTEM, $pass, [whether has system])
850
851 #### test for sbrk ###
852 cat > $t <<EOT
853 #include <unistd.h>
854 int main() {
855   void *ptr  = sbrk(0); 
856 }
857 EOT
858 test_link "whether has sbrk" "yes" "no" ""
859 AC_DEFINE_UNQUOTED(CMK_HAS_SBRK, $pass, [whether has sbrk])
860
861 #### test for mstats ###
862 cat > $t <<EOT
863 #include <malloc.h>
864 int main() {
865   struct mstats ms = mstats();
866 }
867 EOT
868 test_link "whether has mstats" "yes" "no" ""
869 AC_DEFINE_UNQUOTED(CMK_HAS_MSTATS, $pass, [whether has mstats])
870
871 #### test for mallinfo ###
872 cat > $t <<EOT
873 #include <malloc.h>
874 int main() {
875   struct mallinfo mi = mallinfo();
876 }
877 EOT
878 test_link "whether has mallinfo" "yes" "no" ""
879 AC_DEFINE_UNQUOTED(CMK_HAS_MALLINFO, $pass, [whether has mallinfo])
880
881 #### test for popen ###
882 cat > $t <<EOT
883 #include <stdio.h>
884 int main() {
885   FILE *p = popen("/bin/ps", "r");
886   pclose(p);
887 }
888 EOT
889 test_link "whether has popen" "yes" "no" ""
890 AC_DEFINE_UNQUOTED(CMK_HAS_POPEN, $pass, [whether has popen])
891
892 #### test for poll ###
893 cat > $t <<EOT
894 #include <poll.h>
895 void foo(void) { 
896   struct pollfd pos[[3]];
897   poll(pos, 1, 1);
898 }
899 EOT
900 test_cxx "whether has poll" "yes" "no" ""
901 AC_DEFINE_UNQUOTED(CMK_USE_POLL, $pass, [whether the poll syscall exists])
902
903 #### check if getpagesize exists ####
904 cat > $tc <<EOT
905 #include <unistd.h>
906
907 int main(int argc, char **argv) {
908     int s = getpagesize();
909 }
910 EOT
911 test_linkc "whether has getpagesize" "yes" "no" ""
912 AC_DEFINE_UNQUOTED(CMK_HAS_GETPAGESIZE, $pass, [whether getpagesize exists])
913
914 #### check if getpid exists ####
915 cat > $tc <<EOT
916 #include <sys/types.h>
917 #include <unistd.h>
918
919 int main(int argc, char **argv) {
920     pid_t pid = getpid();
921 }
922 EOT
923 test_linkc "whether has getpid" "yes" "no" ""
924 AC_DEFINE_UNQUOTED(CMK_HAS_GETPID, $pass, [whether getpid exists])
925
926 #### check if kill exists ####
927 cat > $tc <<EOT
928 #include <sys/types.h>
929 #include <unistd.h>
930 #include <signal.h>
931
932 int main(int argc, char**argv) 
933 {
934     pid_t pid = getpid();
935     kill(pid, 9);
936 }
937 EOT
938 test_linkc "whether has kill" "yes" "no" ""
939 AC_DEFINE_UNQUOTED(CMK_HAS_KILL, $pass, [whether kill exists])
940
941 #### test for setpriority ###
942 cat > $t <<EOT
943 #include <sys/time.h>
944 #include <sys/resource.h>
945 void foo(void) { 
946   setpriority(PRIO_PROCESS, 0, 0);
947 }
948 EOT
949 test_cxx "whether has setpriority" "yes" "no" ""
950 AC_DEFINE_UNQUOTED(CMK_HAS_SETPRIORITY, $pass, [whether the setpriority exists])
951
952 #### test for system ###
953 cat > $t <<EOT
954 #include "ckdll_system.C"
955 EOT
956 test_cxx "whether to use signal-safe system() " "yes" "no" ""
957 AC_DEFINE_UNQUOTED(CMK_SIGSAFE_SYSTEM, $pass, [whether to use signal-safe system()])
958
959 ### test sched_setaffinity ####
960 cat > $tc <<EOT
961 #include <stdlib.h>
962 #include <stdio.h>
963 #include <unistd.h>
964
965 #define _GNU_SOURCE
966 #include <sched.h>
967 long sched_setaffinity(pid_t pid, unsigned int len, unsigned long *user_mask_ptr);
968 long sched_getaffinity(pid_t pid, unsigned int len, unsigned long *user_mask_ptr);
969
970 int main()
971 {
972   unsigned long mask = 0xffffffff;
973   unsigned int len = sizeof(mask);
974
975   if (sched_setaffinity(0, len, &mask) < 0) {
976     return -1;
977   }
978   return 0;
979 }
980 EOT
981 test_linkc "whether sched_setaffinity call exists" "yes" "no" ""
982 AC_DEFINE_UNQUOTED(CMK_HAS_SETAFFINITY, $pass, [whether the sched_setaffinity() exists])
983
984 ### test pthread_setaffinity_np ####
985 cat > $tc <<EOT
986 #include <stdlib.h>
987 #include <stdio.h>
988 #include <unistd.h>
989 #include <pthread.h>
990
991 int main()
992 {
993   unsigned long mask = 0xffffffff;
994   unsigned int len = sizeof(mask);
995
996   if (pthread_setaffinity_np(pthread_self(), len, &mask) < 0) {
997     return -1;
998   }
999   return 0;
1000 }
1001 EOT
1002 test_linkc "whether pthread_setaffinity_np call exists" "yes" "no" "-lpthread"
1003 AC_DEFINE_UNQUOTED(CMK_HAS_PTHREAD_SETAFFINITY, $pass, [whether the pthread_setaffinity_np() exists])
1004
1005
1006 ### check libnuma on Linux ####
1007 if test "$WITH_NUMA" = "yes"
1008 then
1009 cat > $tc <<EOT
1010 #include <stdlib.h>
1011 #include <stdio.h>
1012 #include <linux/mempolicy.h>
1013 #include <numaif.h>
1014 #include <numa.h>
1015
1016 int main()
1017 {
1018   if (get_mempolicy(NULL, NULL, 0, 0, 0) == 0) return 0;
1019   return -1;
1020 }
1021 EOT
1022 test_linkc "whether libnuma exists" "yes" "no" "-lnuma"
1023 AC_DEFINE_UNQUOTED(CMK_HAS_NUMACTRL, $pass, [whether NUMA control related functions exist])
1024 if test $pass -eq 1
1025 then
1026         add_flag 'CMK_SYSLIBS="$CMK_SYSLIBS -lnuma"' "libnuma"
1027 fi
1028 fi
1029
1030 #### check bindprocessors on AIX ####
1031 cat > $tc <<EOT
1032 #include <stdlib.h>
1033 #include <stdio.h>
1034 #include <unistd.h>
1035
1036 #include <sys/processor.h>
1037
1038 int main()
1039 {
1040   int retValue = 0;
1041   int pid;
1042   pid = getpid();
1043   if (bindprocessor(BINDPROCESS, pid, 0) == -1) return -1;
1044   return 0;
1045 }
1046 EOT
1047 test_linkc "whether bindprocessor call exists" "yes" "no" ""
1048 AC_DEFINE_UNQUOTED(CMK_HAS_BINDPROCESSOR, $pass, [whether the bindprocessor()
1049 exists])
1050
1051
1052 #### check if dlopen works ####
1053 skip_dl=0
1054 # for bproc, ignore -ldl
1055 test -n "$CMK_BPROC" && skip_dl=1
1056 test -n "$CMK_NO_DL" && skip_dl=1
1057 dl_opt='-ldl'
1058 #workaround for pgcc 4.0, -ldl crash linking, so use -Wl,-ldl to skip the prelinker.
1059 case "$CMK_CXX" in
1060 pgCC*) dl_opt='-Wl,-ldl' ;;
1061 esac
1062
1063 if test $skip_dl -eq 0 
1064 then
1065
1066 cat > $t <<EOT
1067 #include "ckdll_dlopen.C"
1068 int main() {
1069         CkDll dll("foo.so");
1070         return 0;
1071 }
1072 EOT
1073 test_link "whether dlopen links without $dl_opt" "yes" "no" ""
1074 noldl=$pass
1075 test_link "whether dlopen links with $dl_opt" "yes" "no" "$dl_opt"
1076 if test $pass -eq 1
1077 then 
1078 #dlopen requires -ldl: add it to our link line
1079         add_flag CMK_LIBS='"$CMK_LIBS '$dl_opt'"' "dlopen"
1080 fi
1081
1082 if test $pass -eq 1 -o $noldl -eq 1
1083 then
1084 # One version or another of dlopen worked: compile it in
1085         AC_DEFINE_UNQUOTED(CMK_DLL_USE_DLOPEN, 1, [dlopen])
1086 fi
1087
1088 ### test gethostname ####
1089 cat > $tc <<EOT
1090 #ifdef WIN32
1091 #include <Winsock2.h>
1092 #else
1093 #include <stdlib.h>
1094 #include <stdio.h>
1095 #include <unistd.h>
1096 #endif
1097
1098 int main()
1099 {
1100   char hostname[[1000]];
1101   gethostname(hostname, 999);
1102   return 0;
1103 }
1104 EOT
1105 test_linkc "whether gethostname call exists" "yes" "no" ""
1106 AC_DEFINE_UNQUOTED(CMK_HAS_GETHOSTNAME, $pass, [whether gethostname() exists])
1107
1108 #### check if getProcAddress works ####
1109 cat > $t <<EOT
1110 #include "ckdll_win32.C"
1111 EOT
1112 test_cxx "whether getProcAddress works" "yes" "no" ""
1113 AC_DEFINE_UNQUOTED(CMK_DLL_USE_WIN32, $pass, [whether getProcAddress works])
1114
1115 fi    # end of skip_dl
1116
1117 #### check if socklen_t exists ####
1118 cat > $t <<EOT
1119 #include <sys/types.h>
1120 #include <sys/socket.h>
1121
1122 void foo(void) {
1123         int i;
1124         socklen_t s=sizeof(i);
1125 }
1126 EOT
1127 test_cxx "whether has socklen_t" "yes" "no" ""
1128 AC_DEFINE_UNQUOTED(CMK_HAS_SOCKLEN, $pass, [whether has socklen_t])
1129
1130 #### check if mmap exists ####
1131 cat > $t <<EOT
1132 #include <sys/types.h>
1133 #include <sys/mman.h>
1134
1135 void *foo(void *a,int l,int fd) {
1136         return mmap((caddr_t)a,l,PROT_READ+PROT_WRITE,
1137                  MAP_FIXED+MAP_PRIVATE,fd,0);
1138 }
1139 EOT
1140 test_cxx "whether the mmap() syscall exists" "yes" "no" ""
1141 AC_DEFINE_UNQUOTED(CMK_HAS_MMAP, $pass, [whether the mmap() syscall exists])
1142
1143 #### check if mmap accepts MAP_ANON ####
1144 cat > $t <<EOT
1145 #include <sys/types.h>
1146 #include <sys/mman.h>
1147
1148 void *foo(void *a,int l) {
1149         return mmap((caddr_t)a,l,PROT_READ+PROT_WRITE,
1150                 MAP_FIXED+MAP_PRIVATE+MAP_ANON,-1,0);
1151 }
1152 EOT
1153 test_cxx "whether mmap() accepts MAP_ANON" "yes" "no" ""
1154 AC_DEFINE_UNQUOTED(CMK_HAS_MMAP_ANON, $pass, [whether mmap() accepts MAP_ANON])
1155
1156 #### check if mmap accepts MAP_NORESERVE ####
1157 cat > $t <<EOT
1158 #include <sys/types.h>
1159 #include <sys/mman.h>
1160
1161 void *foo(void *a,int l) {
1162         return mmap((caddr_t)a,l,PROT_READ+PROT_WRITE,
1163                 MAP_FIXED+MAP_PRIVATE+MAP_NORESERVE,-1,0);
1164 }
1165 EOT
1166 test_cxx "whether mmap() accepts MAP_NORESERVE" "yes" "no" ""
1167 AC_DEFINE_UNQUOTED(CMK_HAS_MMAP_NORESERVE, $pass, [whether mmap() accepts MAP_NORESERVE])
1168
1169 #### check if get_myaddress exists ####
1170 cat > $t <<EOT
1171 #include <rpc/rpc.h>
1172
1173 void foo(void *a) {
1174     get_myaddress((struct sockaddr_in*)a);
1175 }
1176 EOT
1177 test_cxx "whether get_myaddress() exists" "yes" "no" ""
1178 AC_DEFINE_UNQUOTED(CMK_HAS_GET_MYADDRESS, $pass, [whether get_myaddress() exists])
1179
1180 #### check if glibc backtrace exists ####
1181 cat > $t <<EOT
1182 #include "cmibacktrace.c"
1183
1184 int main() {
1185         int nLevels=1;
1186         void *stack;
1187         CmiBacktraceRecord(&stack,0,&nLevels);
1188         return 0;
1189 }
1190 EOT
1191 TRACE_LINK_FLAG="-rdynamic"
1192 test_link "whether glibc backtrace works" "yes" "no" "-DCMK_USE_BACKTRACE=1 $TRACE_LINK_FLAG"
1193 AC_DEFINE_UNQUOTED(CMK_USE_BACKTRACE, $pass, [whether glibc backtrace works])
1194
1195 if test $strictpass -eq 1
1196 then 
1197         add_flag 'CMK_LD="$CMK_LD '$TRACE_LINK_FLAG'"' "backtrace"
1198         add_flag 'CMK_LDXX="$CMK_LDXX '$TRACE_LINK_FLAG'"' "backtrace"
1199 fi
1200
1201 #### test sleep ####
1202 cat > $t <<EOT
1203 #include <unistd.h>
1204 int main() {
1205   sleep(1);
1206   return 0;
1207 }
1208 EOT
1209 test_cxx "whether has sleep " "yes" "no" ""
1210 AC_DEFINE_UNQUOTED(CMK_HAS_SLEEP, $pass, [whether has sleep])
1211
1212 #### test usleep ####
1213 cat > $t <<EOT
1214 #include <unistd.h>
1215 int main() {
1216   usleep(100);
1217   return 0;
1218 }
1219 EOT
1220 test_cxx "whether has usleep " "yes" "no" ""
1221 AC_DEFINE_UNQUOTED(CMK_HAS_USLEEP, $pass, [whether has usleep])
1222
1223 #### test personality() and ADDR_NO_RANDOMIZE ####
1224 # Only works on modern Linux systems
1225 cat > $t <<EOT
1226 #include <sys/personality.h>
1227 int main() {
1228     int orig_persona = personality(0xffffffff);
1229     personality(orig_persona | ADDR_NO_RANDOMIZE);
1230     return 0;
1231 }
1232 EOT
1233 test_cxx "whether personality() and ADDR_NO_RANDOMIZE exist" "yes" "no" ""
1234 AC_DEFINE_UNQUOTED(CMK_HAS_ADDR_NO_RANDOMIZE, $pass, [whether personality() and ADDR_NO_RANDOMIZE exist])
1235
1236
1237 #### test if has zlib ####
1238 # bproc doesnot like -lz in any case
1239 if test -z "$CMK_BPROC"
1240 then
1241
1242 cat > $t <<EOT
1243 #include <zlib.h>
1244 int main() { 
1245   gzFile f = gzopen("/tmp/x","r");
1246   gzprintf(f, "test...\n");
1247   gzclose(f);
1248   return 0;
1249 }
1250 EOT
1251 test_link "whether has zlib" "yes" "no" "-lz"
1252 AC_DEFINE_UNQUOTED(CMK_PROJECTIONS_USE_ZLIB, $pass, [whether has zlib])
1253 if test $pass -eq 1
1254 then 
1255         add_flag 'CMK_LIBZ="-lz"' "zlib"
1256 fi
1257
1258 fi
1259
1260 #### test if has elf.h ####
1261 cat > $t <<EOT
1262 #include <elf.h>
1263 typedef Elf32_Addr ELF_TYPE_Addr;
1264 int main() { 
1265 }
1266 EOT
1267 test_cxx "whether has elf.h " "yes" "no" ""
1268 AC_DEFINE_UNQUOTED([CMK_HAS_ELF_H], $pass, [whether has elf.h])
1269
1270 #### test if has Multiprocessing.h for apple ####
1271 cat > $t <<EOT
1272 #include <Carbon/Carbon.h>
1273 #include <Multiprocessing.h>
1274 int main() {
1275   int a = MPProcessorsScheduled();
1276 }
1277 EOT
1278 test_cxx "whether has Multiprocessing.h for Apple " "yes" "no" ""
1279 AC_DEFINE_UNQUOTED([CMK_HAS_MULTIPROCESSING_H], $pass, [whether has Multiprocessing.h])
1280
1281 #### test if "ntohl" is available ####
1282 cat > $t <<EOT
1283 #if defined(_WIN32) && ! defined(__CYGWIN__) || defined(__MINGW_H)
1284 #include <winsock.h>
1285 #else
1286 #include <netinet/in.h>
1287 #include <arpa/inet.h>
1288 #endif
1289
1290 int main() {
1291   int i = 100;
1292   i = ntohl(i);
1293   return 0;
1294 }
1295 EOT
1296 test_link "whether ntohl is available" "yes" "no" ""
1297 AC_DEFINE_UNQUOTED(CMK_HAS_NTOHL, $pass, [whether ntohl is available])
1298
1299 ### test for libjpeg ####
1300 cat > $t <<EOT
1301 #include <stdio.h>
1302 #include <stdlib.h>
1303 #include "jpeglib.h"
1304
1305 int main()
1306 {
1307   struct jpeg_compress_struct cinfo;
1308   jpeg_create_compress(&cinfo);
1309   return 0;
1310 }
1311 EOT
1312 test_link "whether has libjpeg" "yes" "no" "-ljpeg"
1313 AC_DEFINE_UNQUOTED(CMK_USE_LIBJPEG, $pass, [whether has libjpeg])
1314 if test $pass -eq 1
1315 then
1316         add_flag 'CMK_LIBJPEG="-ljpeg"' "libjpeg"
1317 fi
1318
1319 #### check if PAPI exists ####
1320 if test -n "$CMK_USE_PAPI"
1321 then
1322 cat > $t <<EOT
1323 #include <stdio.h>
1324 #include <papi.h>
1325                                                                                 
1326 int main() {
1327     int Events[[1]] = { PAPI_TOT_CYC };
1328     if (PAPI_start_counters(Events, 1) != PAPI_OK) return 1;
1329     return 0;
1330 }
1331 EOT
1332 test_link "whether PAPI exists" "yes" "no" "-lpapi"
1333 AC_DEFINE_UNQUOTED(CMK_HAS_COUNTER_PAPI, $pass, [whether PAPI exists])
1334 if test $pass -eq 1
1335 then 
1336         add_flag 'CMK_LIBS="$CMK_LIBS -lpapi"' "papi"
1337 fi
1338 fi
1339
1340 #### test if Python headers are installed ####
1341 PYTHON_VERSION=`python -V 2>&1 | awk {'print $2'} | awk -F. {'print $1"."$2'}`
1342 cat > $t <<EOT
1343 #include "python${PYTHON_VERSION}/Python.h"
1344 #include "python${PYTHON_VERSION}/compile.h"
1345 #include "python${PYTHON_VERSION}/eval.h"
1346 #include "python${PYTHON_VERSION}/node.h"
1347
1348 int main() {
1349     Py_Initialize();
1350     PyEval_InitThreads();
1351     struct _node* programNode = PyParser_SimpleParseString("return 1\n",Py_file_input);
1352     PyCodeObject *program = PyNode_Compile(programNode, "");
1353 }
1354 EOT
1355 test_link "whether Python is installed" "yes" "no" "-lpython$PYTHON_VERSION -lpthread -lutil -ldl"
1356 AC_DEFINE_UNQUOTED(CMK_HAS_PYTHON, $pass, [whether Python is installed])
1357 AC_DEFINE_UNQUOTED(CMK_PYTHON_VERSION, ${PYTHON_VERSION}, [Python version])
1358 if test $pass -eq 1
1359 then
1360         add_flag "CMK_BUILD_PYTHON=$PYTHON_VERSION" "python"
1361 fi
1362
1363 #### test if it can build shared library ####
1364 cat > $t <<EOT
1365 #include "stdlib.h"
1366 extern int foo();
1367 int foo1() { 
1368   void * t= malloc(2);
1369   foo();
1370   return 0;
1371 }
1372 EOT
1373 test_linkso "whether can build shared library" "yes" "no" ""
1374 if test $pass -eq 0
1375 then 
1376         add_flag 'CMK_NO_BUILD_SHARED="true"' "build-shared"
1377 else
1378         BUILD_SHARED=1
1379         if test "$BUILD_MPI" = "1"
1380         then
1381 cat > $t <<EOT
1382 #include "stdlib.h"
1383 #include "mpi.h"
1384 extern int foo();
1385 int foo(int argc, char ** argv) {
1386   void * t= malloc(2);
1387   foo();
1388   MPI_Init(&argc, &argv);
1389   return 0;
1390 }
1391 EOT
1392                 test_linkso "whether can build shared library with MPI" "yes" "no" ""
1393                 BUILD_SHARED=$pass
1394         fi
1395         if test $BUILD_SHARED -eq 1
1396         then
1397                 add_flag 'CMK_NO_BUILD_SHARED="false"' "build-shared"
1398         else
1399                 add_flag 'CMK_NO_BUILD_SHARED="true"' "build-shared"
1400         fi
1401 fi
1402
1403 #### test the version number of bproc ####
1404 if test -n "$CMK_BPROC"
1405 then
1406 cat > $t <<EOT
1407 #include <stdio.h>
1408 #include <sys/bproc.h>
1409 int main()
1410 {
1411   struct bproc_version_t vers;
1412   bproc_version(&vers);
1413   printf("%s\n", vers.version_string);
1414 }
1415 EOT
1416 test_link "whether bproc compiles" "yes" "no" "-lbproc"
1417 if test $pass -eq 1
1418 then 
1419 AC_MSG_CHECKING("bproc version")
1420 bproc_ver=`./testlink`
1421 if test x$bproc_ver = x
1422 then
1423 test_result 0 "bproc version" "ERROR" ""
1424 test_finish 1
1425 else
1426 test_result 0 "bproc version" "$bproc_ver" ""
1427 fi
1428 bproc_ver=`echo $bproc_ver | cut -d'.' -f1`
1429 AC_DEFINE_UNQUOTED(CMK_BPROC_VERSION, $bproc_ver, [bproc version])
1430 fi
1431 fi
1432
1433 #### test the if command sync exists ####
1434 AC_CHECK_PROG(SYNC, sync, sync )
1435 if test -n "$SYNC"
1436 then
1437 AC_DEFINE_UNQUOTED(CMK_HAS_SYNC, 1, [sync program])
1438 fi
1439
1440 ################## Fortran #########################
1441
1442 #echo "set F77 compiler as: $CMK_CF77"
1443 AC_MSG_CHECKING("F77 compiler as")
1444 AC_MSG_RESULT("$CMK_CF77")
1445
1446 AC_MSG_CHECKING("whether Fortran 77 compiler works")
1447 ### test fortran 77 compiler ###
1448 cat > conftest.f <<EOF
1449       SUBROUTINE FOO_foo
1450       END
1451 EOF
1452 $CMK_CF77 -c conftest.f > /dev/null 2> /dev/null
1453 if test ! -r conftest.o
1454 then
1455   AC_MSG_RESULT("no")
1456 else
1457   AC_MSG_RESULT("yes")
1458 fi
1459
1460 ### test fortran 90 compiler ###
1461 #echo "set F90 compiler as: $CMK_CF90"
1462 AC_MSG_CHECKING("F90 compiler as")
1463 AC_MSG_RESULT("$CMK_CF90")
1464
1465 AC_MSG_CHECKING("whether Fortran 90 compiler works")
1466 cat > conftest2.f90 <<EOF
1467       SUBROUTINE FOO_foo
1468       END
1469 EOF
1470 $CMK_CF90 -c conftest2.f90 > /dev/null 2> /dev/null
1471 if test ! -r conftest2.o
1472 then
1473   AC_MSG_RESULT("no")
1474 else
1475   AC_MSG_RESULT("yes")
1476   mv -f conftest2.o conftest.o
1477   USE_FORTRAN90=1
1478 fi
1479
1480 ### check fortran name mangling
1481 AC_MSG_CHECKING(subroutine name used by Fortran 90 compiler)
1482
1483 if test -r conftest.o
1484 then
1485   AC_CACHE_VAL(fortran_postfix,
1486
1487   NAME=`$CMK_NM conftest.o | grep "foo_foo__"`
1488   if test "$NAME" != ""
1489   then
1490     fortran_postfix=TWOSCORE
1491     AC_DEFINE_UNQUOTED(CMK_FORTRAN_USES_TWOSCORE, 1, [TWOSCORE])
1492   else
1493     NAME=`$CMK_NM conftest.o | grep "foo_foo_"`
1494     if test "$NAME" != ""
1495     then
1496       fortran_postfix=ONESCORE
1497       AC_DEFINE_UNQUOTED(CMK_FORTRAN_USES_ONESCORE, 1, [ONESCORE])
1498     else
1499       NAME=`$CMK_NM conftest.o | grep "foo_foo"`
1500       if test "$NAME" != ""
1501       then
1502         fortran_postfix=NOSCORE
1503         AC_DEFINE_UNQUOTED(CMK_FORTRAN_USES_NOSCORE, 1, [NOSCORE])
1504       else
1505         NAME=`$CMK_NM conftest.o | grep "FOO_FOO"`
1506         if test "$NAME" != ""
1507         then
1508           fortran_postfix=ALLCAPS
1509           AC_DEFINE_UNQUOTED(CMK_FORTRAN_USES_ALLCAPS, 1, [ALLCAPS])
1510         else
1511           echo "#################################################"
1512           echo "FORTRAN compiler generated name not supported yet"
1513           echo "#################################################"
1514         fi
1515       fi
1516     fi
1517   fi
1518   rm -f conftest.f conftest.o
1519   )
1520   AC_MSG_RESULT($fortran_postfix)
1521 else
1522   AC_MSG_RESULT("Fortran compiler not working")
1523 fi
1524
1525 ### check module name ###
1526
1527 if test "$USE_FORTRAN90" = 1
1528 then
1529   cat > conftest.f90 <<EOF
1530       MODULE testmod
1531         interface 
1532           function fpup_issizing(p)
1533           INTEGER :: p
1534           logical fpup_issizing
1535           end function
1536         end interface
1537       END MODULE
1538 EOF
1539   AC_MSG_CHECKING(Fortran 90 mod name is capital)
1540   $CMK_CF90 -c conftest.f90 > /dev/null 2> /dev/null
1541   name=`ls TESTMOD.* 2>/dev/null`
1542   if test -n "$name"
1543   then
1544         AC_MSG_RESULT("yes")
1545         add_flag 'CMK_MOD_NAME_ALLCAPS=1' "mod name capital"
1546   else
1547         AC_MSG_RESULT("no")
1548         name=`ls testmod.* 2>/dev/null`
1549   fi
1550   if test -n "$name"
1551   then
1552         AC_MSG_CHECKING(Fortran 90 mod name extension)
1553         ext=`echo $name | sed -e 's/^[[^.]]*\.//'`
1554         add_flag 'CMK_MOD_EXT="'$ext'"' "mod name extension"
1555         AC_MSG_RESULT("$ext")
1556         /bin/rm -f $name
1557   fi
1558   /bin/rm -f conftest.f90
1559 fi
1560
1561 ### Check that Linux's C library is recent enough to provide working pthreads
1562 if test "$base_version" = "net-linux" || test "$base_version" = "mpi-linux"
1563 then
1564 case $version in *linux*smp*|*linux*vmi*)
1565     AC_MSG_CHECKING(glibc version)
1566     get_glibc_version
1567     AC_MSG_RESULT($GLIBCVERSION)
1568     if test 0 = `expr $GLIBCVERSION \> 2.2.92`
1569     then
1570        echo "Your version of GLIBC is ancient, and does not have sufficient "
1571        echo "support for pthreads."
1572        exit 1
1573     fi
1574 esac
1575 fi
1576
1577 AC_OUTPUT(
1578 libs/ck-libs/ampi/ampiCC libs/ck-libs/ampi/ampirun,
1579
1580 chmod +x libs/ck-libs/ampi/ampiCC libs/ck-libs/ampi/ampirun
1581 )