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