ab274c3ad1334ab1b697cc99b53312ae391f3687
[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=50914
11 echo $VERSION > ../include/VERSION
12 AC_DEFINE_UNQUOTED([CHARM_VERSION], $VERSION, [Charm++ version number])
13
14 AC_MSG_CHECKING(machine name)
15 version=`pwd | awk -F/ '{print $(NF-1)}'`
16 base_version=`cat .vdir`
17 AC_DEFINE_UNQUOTED(CMK_MACHINE_NAME, "$version",[machine name])
18 AC_MSG_RESULT($version)
19 AC_SUBST(base_version)
20
21 t="test.cpp"
22 tc="test.c"
23
24 charmout="charmconfig.out"
25 /bin/rm -rf $charmout
26
27 # test result passed in $1
28 # If the test suceeded, print $3 and set "pass"/clear "fail"
29 # If the test failed, print $2 and clear "pass"/set "fail"
30 test_result() {
31         if test $1 -eq 0
32         then
33                 AC_MSG_RESULT("$3")
34                 pass="1"
35                 fail="0"
36         else
37                 AC_MSG_RESULT("$4")
38                 pass="0"
39                 fail="1"
40 # For debugging the configure script, just "export autoconf_debug=1"
41 #  to get this verbose data on any failed tests:
42                 if test ! -z "$autoconf_debug"
43                 then
44                         echo "------- test script for $2 failed:"
45                         cat out
46                         echo "------- the test program was:"
47                         cat $t
48                         echo "-------"
49                 fi
50         fi
51 }
52
53 # Test: tries to compile C file $t (described by $1).
54 #  If successful, prints $2 and sets $pass/clears $fail
55 #  If failure, prints $3 and sets $pass/clears $fail
56 #  additional arguments to c++ compiler are passed as $4
57 test_cc() {
58         AC_MSG_CHECKING("$1")
59         cat $tc >> $charmout
60         echo $CMK_CC -I../include -I. $CMK_LIBDIR $CMK_INCDIR $OPTS_CC $OPTS_LD -c $tc -o test.o $4 >> $charmout
61         $CMK_CC -I../include -I. $CMK_LIBDIR $CMK_INCDIR $OPTS_CC $OPTS_LD -c $tc -o test.o $4 > out 2>&1
62         test_result $? "$1" "$2" "$3"
63         strictpass=$pass
64         strictfail=$fail
65         if test $pass -eq 1
66         then 
67           if cat out | grep -i "warn" > /dev/null 2>&1
68           then 
69             strictpass="0" && strictfail="1"
70           fi
71         fi
72         cat out >> $charmout
73         /bin/rm -f out
74 }
75
76 # Test: tries to compile C++ file $t (described by $1).
77 #  If successful, prints $2 and sets $pass/clears $fail
78 #  If failure, prints $3 and sets $pass/clears $fail
79 #  additional arguments to c++ compiler are passed as $4
80 test_cxx() {
81         AC_MSG_CHECKING("$1")
82         cat $t >> $charmout
83         echo $CMK_CXX -I../include -I. $CMK_LIBDIR $CMK_INCDIR $OPTS_CXX $OPTS_LD -c $t -o test.o $4 >> $charmout
84         $CMK_CXX -I../include -I. $CMK_LIBDIR $CMK_INCDIR $OPTS_CXX $OPTS_LD -c $t -o test.o $4 > out 2>&1
85         test_result $? "$1" "$2" "$3"
86         strictpass=$pass
87         strictfail=$fail
88         if test $pass -eq 1
89         then 
90           if cat out | grep -i "warn" > /dev/null 2>&1
91           then 
92             strictpass="0" && strictfail="1"
93           fi
94         fi
95         cat out >> $charmout
96         /bin/rm -f out
97 }
98
99 # Testlink: tries to compile and link a C++ file $t (described by $1).
100 #  If successful, prints $2 and sets $pass/clears $fail
101 #  If failure, prints $3 and sets $pass/clears $fail
102 #  additional arguments to c++ compiler are passed as $4
103 test_link() {
104         AC_MSG_CHECKING("$1")
105         cat $t >> $charmout
106         echo $CMK_CXX -I../include -I. $CMK_INCDIR $OPTS_CXX -c $t -o test.o $4 >> $charmout
107         $CMK_CXX -I../include -I. $CMK_INCDIR $OPTS_CXX -c $t -o test.o $4 > out 2>&1
108         if test $? = 1
109         then
110           test_result 1 "$1" "$2" "$3"
111         else
112           echo $CMK_LDXX -o testlink test.o $CMK_LIBDIR $OPTS_LD $4 >> $charmout
113           $CMK_LDXX -o testlink test.o $CMK_LIBDIR $OPTS_LD $4 > out 2>&1
114           test_result $? "$1" "$2" "$3"
115         fi
116         strictpass=$pass
117         strictfail=$fail
118         if test $pass -eq 1
119         then 
120           if cat out | grep -i "warn" > /dev/null 2>&1
121           then 
122             strictpass="0" && strictfail="1"
123           fi
124         fi
125         cat out >> $charmout
126         /bin/rm -f out
127 }
128
129 # Testlinkc: tries to compile and link a C file $t (described by $1).
130 #  If successful, prints $2 and sets $pass/clears $fail
131 #  If failure, prints $3 and sets $pass/clears $fail
132 #  additional arguments to c++ compiler are passed as $4
133 test_linkc() {
134         AC_MSG_CHECKING("$1")
135         cat $tc >> $charmout
136         echo $CMK_CC -I../include -I. $CMK_INCDIR $OPTS_CC -c $tc -o test.o $4 >> $charmout
137         $CMK_CC -I../include -I. $CMK_INCDIR $OPTS_CC -c $tc -o test.o $4 > out 2>&1
138         if test $? = 1
139         then
140           test_result 1 "$1" "$2" "$3"
141         else
142           echo $CMK_LD -o testlink test.o $CMK_LIBDIR $OPTS_LD $4 >> $charmout
143           $CMK_LD -o testlink test.o $CMK_LIBDIR $OPTS_LD $4 > out 2>&1
144           test_result $? "$1" "$2" "$3"
145         fi
146         strictpass=$pass
147         strictfail=$fail
148         if test $pass -eq 1
149         then 
150           if cat out | grep -i "warn" > /dev/null 2>&1
151           then 
152             strictpass="0" && strictfail="1"
153           fi
154         fi
155         cat out >> $charmout
156         /bin/rm -f out
157 }
158
159 # test_linkso $1 $2 $3 $4, where
160 # $1: debug msg
161 # $2: yes msg
162 # $3: no msg
163 # $4: extra link option
164 test_linkso() {
165         AC_MSG_CHECKING("$1")
166         cat $t >> $charmout
167         echo $CMK_CXX -I../include -I. $CMK_INCDIR $OPTS_CXX -c $t -o test.o $4 >> $charmout
168         $CMK_CXX -I../include -I. $CMK_INCDIR $OPTS_CXX -c $t -o test.o $4 > out 2>&1
169         if test $? = 1
170         then
171           test_result 1 "$1" "$2" "$3"
172         else
173           echo $CMK_LD -I../include -I. $CMK_LIBDIR $OPTS_LD $CMK_LD_SHARED test.o -o testlink.$CMK_SHARED_SUF $4 >> $charmout
174           $CMK_LD -I../include -I. $CMK_LIBDIR $OPTS_LD $CMK_LD_SHARED test.o -o testlink.$CMK_SHARED_SUF $4 > out 2>&1
175           test_result $? "$1" "$2" "$3"
176         fi
177         cat out >> $charmout
178         /bin/rm -f out testlink.$CMK_SHARED_SUF
179 }
180
181 # add into conv-mach-opt.sh
182 # add_flag $1 $2
183 # $2 is description
184 add_flag() {
185         if grep "$1" conv-mach-opt.sh  > /dev/null 2>&1
186         then
187           true
188         else
189           cat >> ../include/conv-mach-opt.sh << EOT
190
191 # Option added by configure script's $2 section
192 $1
193
194 EOT
195         fi
196 }
197
198 test_finish() {
199         rm -f $t $tc testlink test.o    > /dev/null 2>&1
200         /bin/rm -f out
201         exit $1
202 }
203
204 # try to decide the version of glibc
205 get_glibc_version() {
206 t=test.c
207 cat > $t <<EOT
208 #include <stdio.h>
209 #include <gnu/libc-version.h>
210 int main (void) { puts (gnu_get_libc_version ()); return 0; }
211 EOT
212 gcc -o gver test.c
213 GLIBCVERSION=`./gver`
214 /bin/rm -f $t gver
215 }
216
217 cat > $t <<EOT
218 #include <stdio.h>
219 void foo(void) {
220         printf("Hello, world!\n");
221 }
222 EOT
223 #echo "set C++ compiler as: $CMK_CXX $OPTS_CXX $OPTS"
224 AC_MSG_CHECKING("C++ compiler as")
225 AC_MSG_RESULT("$CMK_CXX $OPTS_CXX $OPTS")
226 test_cxx "whether C++ compiler works" "ok" "no" ""
227 if test $fail -eq 1
228 then
229         echo "Cannot compile C++ programs with $CMK_CXX"
230         echo " (check your charm++ version)"
231         test_finish 1
232 fi
233
234 cat > $t <<EOT
235 #include <stdio.h>
236 int main() {
237         printf("Hello, world!\n");
238         return 0;
239 }
240 EOT
241 #echo "set C++ linker as: $CMK_LDXX $OPTS_LDXX"
242 AC_MSG_CHECKING("C++ linker as")
243 AC_MSG_RESULT("$CMK_LDXX $OPTS_LDXX")
244 test_link "whether linker works" "ok" "no" ""
245 if test $fail -eq 1
246 then
247         echo "Cannot link C++ programs with $CMK_LDXX"
248         echo " (check your charm++ version)"
249         test_finish 1
250 fi
251
252 if test "$base_version" = "net-linux" 
253 then
254   test_link "whether linker accept --allow-multiple-definition" "ok" "no" "-Wl,--allow-multiple-definition"
255   if test $pass -eq 1
256   then
257         add_flag CMK_LDXX='"$CMK_LDXX -Wl,--allow-multiple-definition"' "net-linux linker"
258   fi
259 fi
260
261 # Perform the tests
262
263 #### Check bool ####
264 cat > $t <<EOT
265 #include <stdlib.h>
266 bool foo(void) { return true; }
267 EOT
268 test_cxx "whether C++ bool works" "ok" "no" ""
269 AC_DEFINE_UNQUOTED(CMK_BOOL_DEFINED, $pass, [whether C++ bool works])
270
271 #### Check long long ####
272 cat > $t <<EOT
273 #include <stdlib.h>
274 long long foo(void) { return 17; }
275 EOT
276 test_cxx "whether long long works" "ok" "no" ""
277 AC_DEFINE_UNQUOTED(CMK_LONG_LONG_DEFINED, $pass, [whether long long works])
278
279 #### Check __int64 ####
280 cat > $t <<EOT
281 #include <stdlib.h>
282 __int64 foo(void) { return 17; }
283 EOT
284 test_cxx "whether __int64 works" "ok" "no" ""
285 AC_DEFINE_UNQUOTED([CMK___int64_DEFINED], 1, [whether __int64 works])
286
287 #### Check long double ####
288 cat > $t <<EOT
289 #include <stdlib.h>
290 long double foo(void) { return 17.0; }
291 EOT
292 test_cxx "whether long double works" "ok" "no" ""
293 AC_DEFINE_UNQUOTED(CMK_LONG_DOUBLE_DEFINED, $strictpass, [whether long double works])
294
295 #### Check ucontext and FPU pointer ####
296 cat > $t <<EOT
297 #include <ucontext.h>
298 struct _libc_fpstate   fpstate;
299 fpregset_t *fp;
300 EOT
301 test_cxx "whether ucontext has FPU pointer" "yes" "no" ""
302 AC_DEFINE_UNQUOTED(CMK_CONTEXT_FPU_POINTER, $pass, [whether ucontext has pointer])
303
304 if test $pass -eq 1
305 then
306 cat > $t <<EOT
307 #include <ucontext.h>
308
309 int main()
310 {
311   ucontext_t context;
312   context.uc_mcontext.uc_regs = 0;
313 }
314 EOT
315 test_cxx "whether ucontext uses uc_regs" "yes" "no" ""
316 AC_DEFINE_UNQUOTED(CMK_CONTEXT_FPU_POINTER_UCREGS, $pass, [whether ucontext uses uc_regs union])
317 fi
318
319 ###################### C++ Compiler Features #####################
320
321 #### check C inline ####
322 cat > $tc <<EOT
323 inline static int foo()
324 {
325   return 1;
326 }
327 EOT
328 test_cc "whether inline works in C" "yes" "no" ""
329 AC_DEFINE_UNQUOTED(CMK_C_INLINE, $strictpass, [whether C inline works in C])
330
331 #### check explicit ####
332 cat > $t <<EOT
333 #include <stdlib.h>
334 class er {
335  protected:
336    explicit er(unsigned int inType) {};
337 };
338 EOT
339 test_cxx "whether C++ class explicit keyword works" "ok" "no" ""
340 AC_DEFINE_UNQUOTED(CMK_EXPLICIT, $pass, [whether C++ class explicit keyword works])
341
342 #### check if signed char is same as char ####
343 cat > $t <<EOT
344 #include <stdlib.h>
345 class er {
346  protected:
347    void operator()(char &v,const char *desc=NULL) {};
348    void operator()(signed char &v,const char *desc=NULL) {};
349 };
350 EOT
351 test_cxx "whether C++ signed char and char differ" "yes" "no" ""
352 AC_DEFINE_UNQUOTED(CMK_SIGNEDCHAR_DIFF_CHAR, $pass, [whether C++ signed char and char differ])
353
354 #### check if C++ casts work ####
355 cat > $t <<EOT
356 int foo(float *t) {return *reinterpret_cast<int *>(t);}
357 EOT
358 test_cxx "whether C++ *_casts<> work" "ok" "no" ""
359 AC_DEFINE_UNQUOTED(CMK_CPP_CAST_LEGAL, $pass, [C++ *_casts<> work])
360 AC_DEFINE_UNQUOTED(CMK_CPP_CAST_ILLEGAL, $fail, [C++ *_casts<> does not work])
361
362
363 #### check if templated members work ####
364 cat > $t <<EOT
365 typedef void (*func_t)(void);
366 class foo_foo {
367 protected:
368         int len;
369 };
370 class foo: public foo_foo {
371 public:
372         template<func_t f> //Templated member function
373         void memb(void) {f(); len++;}
374 };
375 inline void fn() {}
376 void myfunc()
377 {
378   foo x;
379   x.template memb<fn>();
380 }
381 EOT
382 test_cxx "whether templated member functions work" "ok" "no" ""
383 AC_DEFINE_UNQUOTED(CMK_TEMPLATE_MEMBERS_BROKEN, $fail, [whether templated member functions work])
384
385 ##### check if the stl headers use .h #####
386 cat > $t <<EOT
387 #include <iostream>
388 void foo(void) { std::cout<<"Hello, world"<<std::endl; }
389 EOT
390 test_cxx "whether including STL <foo> works" "ok" "no" ""
391 AC_DEFINE_UNQUOTED(CMK_STL_USE_DOT_H, $fail, [including STL <foo> does not works])
392 AC_DEFINE_UNQUOTED(CMK_STL_DONT_USE_DOT_H, $pass, [including STL <foo> works])
393
394 #### check if std::vector works ######
395 cat > $t <<EOT
396 #include <vector>
397
398 int foo(void) {
399   std::vector<int> v;      
400   v.push_back(2); v.push_back(3);
401   std::vector<int>::iterator it=v.begin();
402   it++;
403   return *it;
404 }
405 EOT
406 test_cxx "whether the std:: names for STL work" "ok" "no" ""
407 AC_DEFINE_UNQUOTED(CMK_USE_STL, $pass, [whether the std:: names for STL work])
408
409 #### check if namespaces can be defined #####
410 cat > $t <<EOT
411 namespace foo {
412         int x;
413 };
414 EOT
415 test_cxx "whether namespaces work" "ok" "no" ""
416 AC_DEFINE_UNQUOTED(CMK_NAMESPACES_BROKEN, $fail, [whether namespaces work])
417
418
419 #### check if typeinfo exists and works #####
420 cat > $t <<EOT
421 #include <typeinfo>
422 const char *foo(void) {
423         int x;
424         return typeid(x).name();
425 }
426 EOT
427 test_cxx "whether typeinfo/typeid works" "ok" "no" ""
428 AC_DEFINE_UNQUOTED(CMK_HAS_TYPEINFO, $pass, [whether typeinfo/typeid works])
429
430
431 #### test if we can have multiple delete like this ####
432 cat > $t <<EOT
433 class foo {
434 public:
435   void operator delete(void*p){};
436   void operator delete(void*p,int*){};
437 };
438 EOT
439 test_cxx "whether operator delete can be overloaded in same class" "ok" "no" ""
440 AC_DEFINE_UNQUOTED(CMK_MULTIPLE_DELETE, $strictpass, [whether operator delete can be overloaded in same class])
441
442
443 #### test if we can use gcc x86 assembly like this ####
444 cat > $t <<EOT
445 double foo(void)
446 {
447   unsigned long long int v;
448   int *lo=0+(int *)&v;
449   int *hi=1+(int *)&v;
450   __asm__ __volatile__(
451       "rdtsc; movl %%edx,%0; movl %%eax,%1"
452       : /* output  */ "=m" (*hi), "=m" (*lo)
453       : /* input */
454       : /* trashes */ "%edx", "%eax"
455   );
456   return v;
457 }
458 EOT
459 test_cxx "whether GCC x86 assembly works" "yes" "no" ""
460 AC_DEFINE_UNQUOTED(CMK_GCC_X86_ASM, $strictpass, [Allows gcc x86 assembly.])
461
462 #### test if we can use gcc IA64 assembly like this ####
463 cat > $t <<EOT
464 double foo(void)
465 {
466         unsigned long long int x;
467         __asm__ __volatile__("mov %0=ar.itc" : "=r"(x) :: "memory");
468         return x;
469 }
470 EOT
471 test_cxx "whether GCC IA64 assembly works" "yes" "no" ""
472 AC_DEFINE_UNQUOTED(CMK_GCC_IA64_ASM, $strictpass, [Allows gcc IA64 assembly.])
473
474
475 ################### Syscalls and Libraries ###################
476
477 #### test for mkstemp ###
478 cat > $t <<EOT
479 #include <stdlib.h>
480 #include <string.h>
481 int main() {
482   char fname[[128]];
483   strcpy(fname, "/tmp/fdXXX.XXX");
484   mkstemp(fname);
485   return 0;
486 }
487 EOT
488 test_link "whether it has mkstemp" "yes" "no" ""
489 AC_DEFINE_UNQUOTED(CMK_USE_MKSTEMP, $pass, [whether it has mkstemp])
490
491 #### test for system ###
492 cat > $t <<EOT
493 #include <stdlib.h>
494 int main() {
495   system("/bin/ls");
496   return 0;
497 }
498 EOT
499 test_link "whether it has system" "yes" "no" ""
500 AC_DEFINE_UNQUOTED(CMK_HAS_SYSTEM, $pass, [whether it has system])
501
502 #### test for poll ###
503 cat > $t <<EOT
504 #include <poll.h>
505 void foo(void) { 
506   struct pollfd pos[[3]];
507   poll(pos, 1, 1);
508 }
509 EOT
510 test_cxx "whether the poll() syscall exists" "yes" "no" ""
511 AC_DEFINE_UNQUOTED(CMK_USE_POLL, $pass, [whether the poll() syscall exists])
512
513 #### test for setpriority ###
514 cat > $t <<EOT
515 #include <sys/time.h>
516 #include <sys/resource.h>
517 void foo(void) { 
518   setpriority(PRIO_PROCESS, 0, 0);
519 }
520 EOT
521 test_cxx "whether the setpriority() exists" "yes" "no" ""
522 AC_DEFINE_UNQUOTED(CMK_HAS_SETPRIORITY, $pass, [whether the setpriority() exists])
523
524 #### test for system ###
525 cat > $t <<EOT
526 #include "ckdll_system.C"
527 EOT
528 test_cxx "whether to use signal-safe system() " "yes" "no" ""
529 AC_DEFINE_UNQUOTED(CMK_SIGSAFE_SYSTEM, $pass, [whether to use signal-safe system()])
530
531 ### test sched_setaffinity ####
532 cat > $tc <<EOT
533 #include <stdlib.h>
534 #include <stdio.h>
535 #include <unistd.h>
536
537 #define _GNU_SOURCE
538 #include <sched.h>
539 long sched_setaffinity(pid_t pid, unsigned int len, unsigned long *user_mask_ptr);
540 long sched_getaffinity(pid_t pid, unsigned int len, unsigned long *user_mask_ptr);
541
542 int main()
543 {
544   unsigned long mask = 0xffffffff;
545   unsigned int len = sizeof(mask);
546
547   if (sched_setaffinity(0, len, &mask) < 0) {
548     return -1;
549   }
550   return 0;
551 }
552 EOT
553 test_linkc "whether sched_setaffinity call exists" "yes" "no" ""
554 AC_DEFINE_UNQUOTED(CMK_HAS_SETAFFINITY, $pass, [whether the sched_setaffinity() exists])
555
556 #### check if dlopen works ####
557 skip_dl=0
558 # for bproc, ignore -ldl
559 test -n "$CMK_BPROC" && skip_dl=1
560 test -n "$CMK_NO_DL" && skip_dl=1
561 dl_opt='-ldl'
562 #workaround for pgcc 4.0, -ldl crash linking, so use -Wl,-ldl to skip the prelinker.
563 case "$CMK_CXX" in
564 pgCC*) dl_opt='-Wl,-ldl' ;;
565 esac
566
567 if test $skip_dl -eq 0 
568 then
569
570 cat > $t <<EOT
571 #include "ckdll_dlopen.C"
572 int main() {
573         CkDll dll("foo.so");
574         return 0;
575 }
576 EOT
577 test_link "whether dlopen links without $dl_opt" "yes" "no" ""
578 noldl=$pass
579 test_link "whether dlopen links with $dl_opt" "yes" "no" "$dl_opt"
580 if test $pass -eq 1
581 then 
582 #dlopen requires -ldl: add it to our link line
583         add_flag CMK_LIBS='"$CMK_LIBS '$dl_opt'"' "dlopen"
584 fi
585
586 if test $pass -eq 1 -o $noldl -eq 1
587 then
588 # One version or another of dlopen worked: compile it in
589         AC_DEFINE_UNQUOTED(CMK_DLL_USE_DLOPEN, 1, [dlopen])
590 fi
591
592 #### check if getProcAddress works ####
593 cat > $t <<EOT
594 #include "ckdll_win32.C"
595 EOT
596 test_cxx "whether getProcAddress works" "yes" "no" ""
597 AC_DEFINE_UNQUOTED(CMK_DLL_USE_WIN32, $pass, [whether getProcAddress works])
598
599 fi    # end of skip_dl
600
601 #### check if socklen_t exists ####
602 cat > $t <<EOT
603 #include <sys/types.h>
604 #include <sys/socket.h>
605
606 void foo(void) {
607         int i;
608         socklen_t s=sizeof(i);
609 }
610 EOT
611 test_cxx "whether it has socklen_t" "yes" "no" ""
612 AC_DEFINE_UNQUOTED(CMK_HAS_SOCKLEN, $pass, [whether it has socklen_t])
613
614 #### check if mmap exists ####
615 cat > $t <<EOT
616 #include <sys/types.h>
617 #include <sys/mman.h>
618
619 void *foo(void *a,int l,int fd) {
620         return mmap((caddr_t)a,l,PROT_READ+PROT_WRITE,
621                  MAP_FIXED+MAP_PRIVATE,fd,0);
622 }
623 EOT
624 test_cxx "whether the mmap() syscall exists" "yes" "no" ""
625 AC_DEFINE_UNQUOTED(CMK_HAS_MMAP, $pass, [whether the mmap() syscall exists])
626
627 #### check if mmap accepts MAP_ANON ####
628 cat > $t <<EOT
629 #include <sys/types.h>
630 #include <sys/mman.h>
631
632 void *foo(void *a,int l) {
633         return mmap((caddr_t)a,l,PROT_READ+PROT_WRITE,
634                 MAP_FIXED+MAP_PRIVATE+MAP_ANON,-1,0);
635 }
636 EOT
637 test_cxx "whether mmap() accepts MAP_ANON" "yes" "no" ""
638 AC_DEFINE_UNQUOTED(CMK_HAS_MMAP_ANON, $pass, [whether mmap() accepts MAP_ANON])
639
640 #### check if get_myaddress exists ####
641 cat > $t <<EOT
642 #include <rpc/rpc.h>
643
644 void foo(void *a) {
645     get_myaddress((struct sockaddr_in*)a);
646 }
647 EOT
648 test_cxx "whether get_myaddress() exists" "yes" "no" ""
649 AC_DEFINE_UNQUOTED(CMK_HAS_GET_MYADDRESS, $pass, [whether get_myaddress() exists])
650
651 #### check if glibc backtrace exists ####
652 cat > $t <<EOT
653 #include "cmibacktrace.c"
654
655 int main() {
656         int nLevels=1;
657         void *stack;
658         CmiBacktraceRecord(&stack,0,&nLevels);
659         return 0;
660 }
661 EOT
662 TRACE_LINK_FLAG="-rdynamic"
663 test_link "whether glibc backtrace works" "yes" "no" "-DCMK_USE_BACKTRACE=1 $TRACE_LINK_FLAG"
664 AC_DEFINE_UNQUOTED(CMK_USE_BACKTRACE, $pass, [whether glibc backtrace works])
665
666 if test $strictpass -eq 1
667 then 
668         add_flag 'CMK_LD="$CMK_LD '$TRACE_LINK_FLAG'"' "backtrace"
669         add_flag 'CMK_LDXX="$CMK_LDXX '$TRACE_LINK_FLAG'"' "backtrace"
670 fi
671
672
673 #### test if has zlib ####
674 # bproc doesnot like -lz in any case
675 if test -z "$CMK_BPROC"
676 then
677
678 cat > $t <<EOT
679 #include <zlib.h>
680 int main() { 
681   gzFile f = gzopen("/tmp/x","r");
682   gzprintf(f, "test...\n");
683   gzclose(f);
684   return 0;
685 }
686 EOT
687 test_link "whether it has zlib" "yes" "no" "-lz"
688 AC_DEFINE_UNQUOTED(CMK_PROJECTIONS_USE_ZLIB, $pass, [whether it has zlib])
689 if test $pass -eq 1
690 then 
691         add_flag 'CMK_LIBZ="-lz"' "zlib"
692 fi
693
694 fi
695
696 #### test if has values.h ####
697 cat > $t <<EOT
698 #include <values.h>
699 int main() { 
700   double d = MAXDOUBLE;
701   return 0;
702 }
703 EOT
704 test_cxx "whether has values.h " "yes" "no" ""
705 AC_DEFINE_UNQUOTED(CMK_HAS_VALUES_H, $pass, [whether has values.h])
706
707 #### test if has alloca.h ####
708 cat > $t <<EOT
709 #include <alloca.h>
710 int main() {
711   double *s=(double *)alloca(sizeof(double));
712   *s=1.0;
713   return 0;
714 }
715 EOT
716 test_cxx "whether has alloca.h " "yes" "no" ""
717 AC_DEFINE_UNQUOTED(CMK_HAS_ALLOCA_H, $pass, [whether has alloca.h])
718
719 #### test if has malloc.h ####
720 cat > $t <<EOT
721 #include <malloc.h>
722 int main() { 
723   return 0;
724 }
725 EOT
726 test_cxx "whether has malloc.h " "yes" "no" ""
727 AC_DEFINE_UNQUOTED(CMK_HAS_MALLOC_H, $pass, [whether has malloc.h])
728
729 #### test if has elf.h ####
730 cat > $t <<EOT
731 #include <elf.h>
732 typedef Elf32_Addr ELF_TYPE_Addr;
733 int main() { 
734 }
735 EOT
736 test_cxx "whether has elf.h " "yes" "no" ""
737 AC_DEFINE_UNQUOTED([CMK_HAS_ELF_H], $pass, [wether has elf.h])
738
739 #### test if has stdint.h ####
740 cat > $t <<EOT
741 #include <stdint.h>
742 int main() { 
743   return 0;
744 }
745 EOT
746 test_cxx "whether has stdint.h " "yes" "no" ""
747 AC_DEFINE_UNQUOTED(CMK_HAS_STDINT_H, $pass, [whether has stdint.h])
748
749 #### check if PAPI exists ####
750 if test -n "$CMK_USE_PAPI"
751 then
752 cat > $t <<EOT
753 #include <stdio.h>
754 #include <papi.h>
755                                                                                 
756 int main() {
757     int Events[[1]] = { PAPI_TOT_CYC };
758     if (PAPI_start_counters(Events, 1) != PAPI_OK) return 1;
759     return 0;
760 }
761 EOT
762 test_link "whether PAPI exists" "yes" "no" "-lpapi"
763 AC_DEFINE_UNQUOTED(CMK_HAS_COUNTER_PAPI, $pass, [whether PAPI exists])
764 if test $pass -eq 1
765 then 
766         add_flag 'CMK_LIBS="$CMK_LIBS -lpapi"' "papi"
767 fi
768 fi
769
770 #### test if Python headers are installed ####
771 cat > $t <<EOT
772 #include "python/Python.h"
773 #include "python/compile.h"
774 #include "python/eval.h"
775 #include "python/node.h"
776
777 int main() {
778     Py_Initialize();
779     PyEval_InitThreads();
780     struct _node* programNode = PyParser_SimpleParseString("return 1\n",Py_file_input);
781     PyCodeObject *program = PyNode_Compile(programNode, "");
782 }
783 EOT
784 PYTHON_VERSION=`python -V 2>&1 | awk {'print $2'} | awk -F. {'print $1"."$2'}`
785 test_link "whether Python is installed" "yes" "no" "-lpython$PYTHON_VERSION -lpthread -lutil -ldl"
786 AC_DEFINE_UNQUOTED(CMK_HAS_PYTHON, $pass, [whether Python is installed])
787 if test $pass -eq 1
788 then
789         add_flag "CMK_BUILD_PYTHON=$PYTHON_VERSION" "python"
790 fi
791
792 #### test if it can build shared library ####
793 cat > $t <<EOT
794 extern int foo();
795 int foo1() { 
796   foo();
797   return 0;
798 }
799 EOT
800 test_linkso "whether it can build shared library" "yes" "no" ""
801 if test $pass -eq 0
802 then 
803         add_flag 'CMK_NO_BUILD_SHARED="true"' "build-shared"
804 fi
805
806 #### test the version number of bproc ####
807 if test -n "$CMK_BPROC"
808 then
809 cat > $t <<EOT
810 #include <stdio.h>
811 #include <sys/bproc.h>
812 int main()
813 {
814   struct bproc_version_t vers;
815   bproc_version(&vers);
816   printf("%s\n", vers.version_string);
817 }
818 EOT
819 test_link "whether bproc compiles" "yes" "no" "-lbproc"
820 if test $pass -eq 1
821 then 
822 AC_MSG_CHECKING("bproc version")
823 bproc_ver=`./testlink`
824 test_result 0 "bproc version" "$bproc_ver" ""
825 bproc_ver=`echo $bproc_ver | cut -d'.' -f1`
826 AC_DEFINE_UNQUOTED(CMK_BPROC_VERSION, $bproc_ver, [bproc version])
827 fi
828 fi
829
830 #### test the if command sync exists ####
831 AC_CHECK_PROG(SYNC, sync, sync )
832 if test -n "$SYNC"
833 then
834 AC_DEFINE_UNQUOTED(CMK_HAS_SYNC, 1, [sync program])
835 fi
836
837 ################## Fortran #########################
838
839 #echo "set F77 compiler as: $CMK_CF77"
840 AC_MSG_CHECKING("F77 compiler as")
841 AC_MSG_RESULT("$CMK_CF77")
842
843 AC_MSG_CHECKING("whether Fortran 77 compiler works")
844 ### test fortran 77 compiler ###
845 cat > conftest.f <<EOF
846       SUBROUTINE FOO_foo
847       END
848 EOF
849 $CMK_CF77 -c conftest.f > /dev/null 2> /dev/null
850 if test ! -r conftest.o
851 then
852   AC_MSG_RESULT("no")
853 else
854   AC_MSG_RESULT("yes")
855 fi
856
857 ### test fortran 90 compiler ###
858 #echo "set F90 compiler as: $CMK_CF90"
859 AC_MSG_CHECKING("F90 compiler as")
860 AC_MSG_RESULT("$CMK_CF90")
861
862 AC_MSG_CHECKING("whether Fortran 90 compiler works")
863 cat > conftest2.f90 <<EOF
864       SUBROUTINE FOO_foo
865       END
866 EOF
867 $CMK_CF90 -c conftest2.f90 > /dev/null 2> /dev/null
868 if test ! -r conftest2.o
869 then
870   AC_MSG_RESULT("no")
871 else
872   AC_MSG_RESULT("yes")
873   mv -f conftest2.o conftest.o
874   USE_FORTRAN90=1
875 fi
876
877 ### check fortran name mangling
878 AC_MSG_CHECKING(subroutine name used by Fortran 90 compiler)
879
880 if test -r conftest.o
881 then
882   AC_CACHE_VAL(fortran_postfix,
883
884   NAME=`$CMK_NM conftest.o | grep "foo_foo__"`
885   if test "$NAME" != ""
886   then
887     fortran_postfix=TWOSCORE
888     AC_DEFINE_UNQUOTED(CMK_FORTRAN_USES_TWOSCORE, 1, [TWOSCORE])
889   else
890     NAME=`$CMK_NM conftest.o | grep "foo_foo_"`
891     if test "$NAME" != ""
892     then
893       fortran_postfix=ONESCORE
894       AC_DEFINE_UNQUOTED(CMK_FORTRAN_USES_ONESCORE, 1, [ONESCORE])
895     else
896       NAME=`$CMK_NM conftest.o | grep "foo_foo"`
897       if test "$NAME" != ""
898       then
899         fortran_postfix=NOSCORE
900         AC_DEFINE_UNQUOTED(CMK_FORTRAN_USES_NOSCORE, 1, [NOSCORE])
901       else
902         NAME=`$CMK_NM conftest.o | grep "FOO_FOO"`
903         if test "$NAME" != ""
904         then
905           fortran_postfix=ALLCAPS
906           AC_DEFINE_UNQUOTED(CMK_FORTRAN_USES_ALLCAPS, 1, [ALLCAPS])
907         else
908           echo "#################################################"
909           echo "FORTRAN compiler generated name not supported yet"
910           echo "#################################################"
911         fi
912       fi
913     fi
914   fi
915   rm -f conftest.f conftest.o
916   )
917   AC_MSG_RESULT($fortran_postfix)
918 else
919   AC_MSG_RESULT("Fortran compiler not working")
920 fi
921
922 ### check module name ###
923
924 if test "$USE_FORTRAN90" = 1
925 then
926   cat > conftest.f90 <<EOF
927       MODULE testmod
928         interface 
929           function fpup_issizing(p)
930           INTEGER :: p
931           logical fpup_issizing
932           end function
933         end interface
934       END MODULE
935 EOF
936   AC_MSG_CHECKING(Fortran 90 mod name is capital)
937   $CMK_CF90 -c conftest.f90 > /dev/null 2> /dev/null
938   name=`ls TESTMOD.* 2>/dev/null`
939   if test -n "$name"
940   then
941         AC_MSG_RESULT("yes")
942         add_flag 'CMK_MOD_NAME_ALLCAPS=1' "mod name capital"
943   else
944         AC_MSG_RESULT("no")
945         name=`ls testmod.* 2>/dev/null`
946   fi
947   if test -n "$name"
948   then
949         AC_MSG_CHECKING(Fortran 90 mod name extension)
950         ext=`echo $name | sed -e 's/^[[^.]]*\.//'`
951         add_flag 'CMK_MOD_EXT="'$ext'"' "mod name extension"
952         AC_MSG_RESULT("$ext")
953         /bin/rm -f $name
954   fi
955   /bin/rm -f conftest.f90
956 fi
957
958 ### go get libpthread.a from charm website ###
959 if test "$base_version" = "net-linux" || test "$base_version" = "mpi-linux"
960 then
961 case $version in
962 *linux*smp*|*linux*vmi*)
963   if test ! -r ../lib/libpthread.a
964   then
965     AC_CHECK_PROG(WGET, wget, wget )
966     AC_CHECK_PROG(LYNX, lynx, lynx )
967     AC_CHECK_PROG(TELNET, telnet, telnet )
968     AC_CHECK_PROG(UUDECODE, uudecode, uudecode )
969     
970     CHARMIP='128.174.241.81'
971 #    CHARMIP='charm.cs.uiuc.edu'
972 #    VERSION=`nm /lib/libc.so.6 | grep "A GLIBC_" | tail -1 | sed -e "s/00000000 A GLIBC_//g"`
973     AC_MSG_CHECKING(glibc version)
974     get_glibc_version
975     AC_MSG_RESULT($GLIBCVERSION)
976     if test 1 = `expr $GLIBCVERSION \> 2.2.92` 
977     then
978       cat >> ./conv-mach-opt.h << EOT
979 #undef CMK_LINUX_PTHREAD_HACK
980 EOT
981     else
982       L="libpthread-$GLIBCVERSION.a"
983       LSO="libpthread-$GLIBCVERSION.so"
984       URL="http://${CHARMIP}/distrib/$L"
985       URLSO="http://${CHARMIP}/distrib/$LSO"
986       finish=0
987       printf "getting $L from $URL ..."
988       if test -n "$WGET"
989       then
990         printf "(wget) ..."
991         $WGET $URL > /dev/null 2>&1  && mv $L ../lib && finish=1
992         $WGET $URLSO > /dev/null 2>&1  && mv $LSO ../lib_so
993       fi
994       if test $finish = 0 && test -n "$LYNX"
995       then
996         printf "(lynx) ..."
997         $LYNX -source $URL > $L 2>/dev/null 
998         if file -L $L | grep 'archive' > /dev/null
999         then
1000           mv $L ../lib && finish=1
1001         fi
1002         $LYNX -source $URLSO > $L 2>/dev/null 
1003       fi
1004       if test $finish = 0 && test -n "$TELNET" && test -n "$UUDECODE"
1005       then
1006         printf "(telnet) ..."
1007         cat > get_libpthread <<EOT
1008 #! /bin/sh
1009 echo "GET /distrib/libpthread-$GLIBCVERSION.uu 1.0"
1010 echo
1011 # exit normally when the telnet session closes.
1012 trap "exit 0" 13
1013 while : ; do
1014  echo
1015  sleep 1
1016 done
1017 EOT
1018         /bin/sh ./get_libpthread | ($TELNET $CHARMIP 80 > .uulib 2>/dev/null); $UUDECODE .uulib 2>/dev/null && rm -f .uulib && mv $L ../lib && finish=1
1019       fi
1020       ln -s $L ../lib/libpthread.a
1021       ln -s $LSO ../lib_so/libpthread.so
1022       if test $finish = 0 || test ! -r ../lib/libpthread.a
1023       then
1024         /bin/rm -f ../lib/libpthread.a
1025         echo "failed"
1026         echo "#####################################################################"
1027         echo "wget, lynx or telnet must be installed to get libpthread.a from charm website."
1028         echo "Alternately, your version of GLIBC ($GLIBCVERSION) is not yet supported--"
1029         echo " contact ppl@cs.uiuc.edu for assistance."
1030         echo "#####################################################################"
1031         exit 1
1032       else
1033         echo "done"
1034       fi
1035     fi
1036   fi
1037   ;;
1038 esac
1039 fi
1040
1041 AC_OUTPUT(
1042 libs/ck-libs/ampi/ampirun,
1043
1044 chmod +x libs/ck-libs/ampi/ampirun
1045 )