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