fixed charm version
[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=60100
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 ! -x 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 cat > $t <<EOT
322 #include <ucontext.h>
323 vrregset_t *v_regs;
324 ucontext_t  uc;
325
326 void foo()
327 {
328   vrregset_t *ptr = uc.uc_mcontext.v_regs;
329 }
330 EOT
331 test_cxx "whether ucontext has pointer (v_regs) of vector type" "yes" "no" ""
332 AC_DEFINE_UNQUOTED(CMK_CONTEXT_V_REGS, $pass, [whether ucontext has pointer (v_regs) of vector type])
333
334 ###################### C++ Compiler Features #####################
335
336 #### check C inline ####
337 cat > $tc <<EOT
338 inline static int foo()
339 {
340   return 1;
341 }
342 EOT
343 test_cc "whether inline works in C" "yes" "no" ""
344 AC_DEFINE_UNQUOTED(CMK_C_INLINE, $strictpass, [whether C inline works in C])
345
346 #### check explicit ####
347 cat > $t <<EOT
348 #include <stdlib.h>
349 class er {
350  protected:
351    explicit er(unsigned int inType) {};
352 };
353 EOT
354 test_cxx "whether C++ class explicit keyword works" "ok" "no" ""
355 AC_DEFINE_UNQUOTED(CMK_EXPLICIT, $pass, [whether C++ class explicit keyword works])
356
357 #### check if signed char is same as char ####
358 cat > $t <<EOT
359 #include <stdlib.h>
360 class er {
361  protected:
362    void operator()(char &v,const char *desc=NULL) {};
363    void operator()(signed char &v,const char *desc=NULL) {};
364 };
365 EOT
366 test_cxx "whether C++ signed char and char differ" "yes" "no" ""
367 AC_DEFINE_UNQUOTED(CMK_SIGNEDCHAR_DIFF_CHAR, $pass, [whether C++ signed char and char differ])
368
369 #### check if C++ casts work ####
370 cat > $t <<EOT
371 int foo(float *t) {return *reinterpret_cast<int *>(t);}
372 EOT
373 test_cxx "whether C++ *_casts<> work" "ok" "no" ""
374 AC_DEFINE_UNQUOTED(CMK_CPP_CAST_LEGAL, $pass, [C++ *_casts<> work])
375 AC_DEFINE_UNQUOTED(CMK_CPP_CAST_ILLEGAL, $fail, [C++ *_casts<> does not work])
376
377
378 #### check if templated members work ####
379 cat > $t <<EOT
380 typedef void (*func_t)(void);
381 class foo_foo {
382 protected:
383         int len;
384 };
385 class foo: public foo_foo {
386 public:
387         template<func_t f> //Templated member function
388         void memb(void) {f(); len++;}
389 };
390 inline void fn() {}
391 void myfunc()
392 {
393   foo x;
394   x.template memb<fn>();
395 }
396 EOT
397 test_cxx "whether templated member functions work" "ok" "no" ""
398 AC_DEFINE_UNQUOTED(CMK_TEMPLATE_MEMBERS_BROKEN, $fail, [whether templated member functions work])
399
400 ##### check if the stl headers use .h #####
401 cat > $t <<EOT
402 #include <iostream>
403 void foo(void) { std::cout<<"Hello, world"<<std::endl; }
404 EOT
405 test_cxx "whether including STL <foo> works" "ok" "no" ""
406 AC_DEFINE_UNQUOTED(CMK_STL_USE_DOT_H, $fail, [including STL <foo> does not works])
407 AC_DEFINE_UNQUOTED(CMK_STL_DONT_USE_DOT_H, $pass, [including STL <foo> works])
408
409 #### check if std::vector works ######
410 cat > $t <<EOT
411 #include <vector>
412
413 int foo(void) {
414   std::vector<int> v;      
415   v.push_back(2); v.push_back(3);
416   std::vector<int>::iterator it=v.begin();
417   it++;
418   return *it;
419 }
420 EOT
421 test_cxx "whether the std:: names for STL work" "ok" "no" ""
422 AC_DEFINE_UNQUOTED(CMK_USE_STL, $pass, [whether the std:: names for STL work])
423
424 #### check if namespaces can be defined #####
425 cat > $t <<EOT
426 namespace foo {
427         int x;
428 };
429 EOT
430 test_cxx "whether namespaces work" "ok" "no" ""
431 AC_DEFINE_UNQUOTED(CMK_NAMESPACES_BROKEN, $fail, [whether namespaces work])
432
433
434 #### check if typeinfo exists and works #####
435 cat > $t <<EOT
436 #include <typeinfo>
437 const char *foo(void) {
438         int x;
439         return typeid(x).name();
440 }
441 EOT
442 test_cxx "whether typeinfo/typeid works" "ok" "no" ""
443 AC_DEFINE_UNQUOTED(CMK_HAS_TYPEINFO, $pass, [whether typeinfo/typeid works])
444
445
446 #### test if we can have multiple delete like this ####
447 cat > $t <<EOT
448 class foo {
449 public:
450   void operator delete(void*p){};
451   void operator delete(void*p,int*){};
452 };
453 EOT
454 test_cxx "whether operator delete can be overloaded in same class" "ok" "no" ""
455 AC_DEFINE_UNQUOTED(CMK_MULTIPLE_DELETE, $strictpass, [whether operator delete can be overloaded in same class])
456
457
458 #### test if we can use gcc x86 assembly like this ####
459 cat > $t <<EOT
460 double foo(void)
461 {
462   unsigned long long int v;
463   int *lo=0+(int *)&v;
464   int *hi=1+(int *)&v;
465   __asm__ __volatile__(
466       "rdtsc; movl %%edx,%0; movl %%eax,%1"
467       : /* output  */ "=m" (*hi), "=m" (*lo)
468       : /* input */
469       : /* trashes */ "%edx", "%eax"
470   );
471   return v;
472 }
473 EOT
474 test_cxx "whether GCC x86 assembly works" "yes" "no" ""
475 AC_DEFINE_UNQUOTED(CMK_GCC_X86_ASM, $strictpass, [Allows gcc x86 assembly.])
476
477 #### test if we can use gcc IA64 assembly like this ####
478 cat > $t <<EOT
479 double foo(void)
480 {
481         unsigned long long int x;
482         __asm__ __volatile__("mov %0=ar.itc" : "=r"(x) :: "memory");
483         return x;
484 }
485 EOT
486 test_cxx "whether GCC IA64 assembly works" "yes" "no" ""
487 AC_DEFINE_UNQUOTED(CMK_GCC_IA64_ASM, $strictpass, [Allows gcc IA64 assembly.])
488
489 #### test if we can use __thread ####
490 cat > $t <<EOT
491 __thread unsigned long long int x;
492 static __thread  int y;
493 void foo(void)
494 {
495         x = 1;
496         y = 1;
497 }
498 EOT
499 test_cxx "whether __thread (Thread Local Storage) is supported" "yes" "no" ""
500 AC_DEFINE_UNQUOTED(CMK_TLS_THREAD, $strictpass, [Allows __thread.])
501
502 #### test if we can build MPI ####
503 cat > $t <<EOT
504 #include "mpi.h"
505 int main(int argc, char **argv)
506 {
507   MPI_Init(&argc, &argv);
508 }
509 EOT
510 mv -f ../include/mpi.h ../include/mpi.h.bak 2>/dev/null
511 test_cxx "whether build on MPI" "yes" "no" ""
512 AC_DEFINE_UNQUOTED(CMK_BUILD_ON_MPI, $strictpass, [build MPI.])
513
514 if test $strictpass -eq 1
515 then
516 cat > $t <<EOT
517 #include "mpi.h"
518 int main(int argc, char **argv)
519 {
520   int thread_level, provided;
521   thread_level = MPI_THREAD_FUNNELED;
522   MPI_Init_thread(&argc, &argv, thread_level, &provided);
523 }
524 EOT
525 test_cxx "whether MPI_Init_thread is supported" "yes" "no" ""
526 AC_DEFINE_UNQUOTED(CMK_MPI_INIT_THREAD, $strictpass, [Allows MPI_Init_thread.])
527 fi
528 mv -f ../include/mpi.h.bak ../include/mpi.h 2>/dev/null
529
530
531 ################### Syscalls and Libraries ###################
532
533 #### test for log2 ###
534 cat > $t <<EOT
535 #include <math.h>
536 int main() {
537   int i = log2(10);
538   return 0;
539 }
540 EOT
541 test_link "whether it has log2" "yes" "no" ""
542 AC_DEFINE_UNQUOTED(CMK_HAS_LOG2, $pass, [whether it has log2])
543
544 #### test for mkstemp ###
545 cat > $t <<EOT
546 #include <stdlib.h>
547 #include <string.h>
548 int main() {
549   char fname[[128]];
550   strcpy(fname, "/tmp/fdXXX.XXX");
551   mkstemp(fname);
552   return 0;
553 }
554 EOT
555 test_link "whether it has mkstemp" "yes" "no" ""
556 AC_DEFINE_UNQUOTED(CMK_USE_MKSTEMP, $pass, [whether it has mkstemp])
557
558 #### test for system ###
559 cat > $t <<EOT
560 #include <stdlib.h>
561 int main() {
562   system("/bin/ls");
563   return 0;
564 }
565 EOT
566 test_link "whether it has system" "yes" "no" ""
567 AC_DEFINE_UNQUOTED(CMK_HAS_SYSTEM, $pass, [whether it has system])
568
569 #### test for poll ###
570 cat > $t <<EOT
571 #include <poll.h>
572 void foo(void) { 
573   struct pollfd pos[[3]];
574   poll(pos, 1, 1);
575 }
576 EOT
577 test_cxx "whether the poll() syscall exists" "yes" "no" ""
578 AC_DEFINE_UNQUOTED(CMK_USE_POLL, $pass, [whether the poll() syscall exists])
579
580 #### test for setpriority ###
581 cat > $t <<EOT
582 #include <sys/time.h>
583 #include <sys/resource.h>
584 void foo(void) { 
585   setpriority(PRIO_PROCESS, 0, 0);
586 }
587 EOT
588 test_cxx "whether the setpriority() exists" "yes" "no" ""
589 AC_DEFINE_UNQUOTED(CMK_HAS_SETPRIORITY, $pass, [whether the setpriority() exists])
590
591 #### test for system ###
592 cat > $t <<EOT
593 #include "ckdll_system.C"
594 EOT
595 test_cxx "whether to use signal-safe system() " "yes" "no" ""
596 AC_DEFINE_UNQUOTED(CMK_SIGSAFE_SYSTEM, $pass, [whether to use signal-safe system()])
597
598 ### test sched_setaffinity ####
599 cat > $tc <<EOT
600 #include <stdlib.h>
601 #include <stdio.h>
602 #include <unistd.h>
603
604 #define _GNU_SOURCE
605 #include <sched.h>
606 long sched_setaffinity(pid_t pid, unsigned int len, unsigned long *user_mask_ptr);
607 long sched_getaffinity(pid_t pid, unsigned int len, unsigned long *user_mask_ptr);
608
609 int main()
610 {
611   unsigned long mask = 0xffffffff;
612   unsigned int len = sizeof(mask);
613
614   if (sched_setaffinity(0, len, &mask) < 0) {
615     return -1;
616   }
617   return 0;
618 }
619 EOT
620 test_linkc "whether sched_setaffinity call exists" "yes" "no" ""
621 AC_DEFINE_UNQUOTED(CMK_HAS_SETAFFINITY, $pass, [whether the sched_setaffinity() exists])
622
623 ### test pthread_setaffinity_np ####
624 cat > $tc <<EOT
625 #include <stdlib.h>
626 #include <stdio.h>
627 #include <unistd.h>
628 #include <pthread.h>
629
630 int main()
631 {
632   unsigned long mask = 0xffffffff;
633   unsigned int len = sizeof(mask);
634
635   if (pthread_setaffinity_np(pthread_self(), len, &mask) < 0) {
636     return -1;
637   }
638   return 0;
639 }
640 EOT
641 test_linkc "whether pthread_setaffinity_np call exists" "yes" "no" "-lpthread"
642 AC_DEFINE_UNQUOTED(CMK_HAS_PTHREAD_SETAFFINITY, $pass, [whether the pthread_setaffinity_np() exists])
643
644 #### check if dlopen works ####
645 skip_dl=0
646 # for bproc, ignore -ldl
647 test -n "$CMK_BPROC" && skip_dl=1
648 test -n "$CMK_NO_DL" && skip_dl=1
649 dl_opt='-ldl'
650 #workaround for pgcc 4.0, -ldl crash linking, so use -Wl,-ldl to skip the prelinker.
651 case "$CMK_CXX" in
652 pgCC*) dl_opt='-Wl,-ldl' ;;
653 esac
654
655 if test $skip_dl -eq 0 
656 then
657
658 cat > $t <<EOT
659 #include "ckdll_dlopen.C"
660 int main() {
661         CkDll dll("foo.so");
662         return 0;
663 }
664 EOT
665 test_link "whether dlopen links without $dl_opt" "yes" "no" ""
666 noldl=$pass
667 test_link "whether dlopen links with $dl_opt" "yes" "no" "$dl_opt"
668 if test $pass -eq 1
669 then 
670 #dlopen requires -ldl: add it to our link line
671         add_flag CMK_LIBS='"$CMK_LIBS '$dl_opt'"' "dlopen"
672 fi
673
674 if test $pass -eq 1 -o $noldl -eq 1
675 then
676 # One version or another of dlopen worked: compile it in
677         AC_DEFINE_UNQUOTED(CMK_DLL_USE_DLOPEN, 1, [dlopen])
678 fi
679
680 ### test gethostname ####
681 cat > $tc <<EOT
682 #include <stdlib.h>
683 #include <stdio.h>
684 #include <unistd.h>
685
686 int main()
687 {
688   char hostname[[1000]];
689   gethostname(hostname, 999);
690   return 0;
691 }
692 EOT
693 test_linkc "whether gethostname call exists" "yes" "no" ""
694 AC_DEFINE_UNQUOTED(CMK_HAS_GETHOSTNAME, $pass, [whether gethostname() exists])
695
696 #### check if getProcAddress works ####
697 cat > $t <<EOT
698 #include "ckdll_win32.C"
699 EOT
700 test_cxx "whether getProcAddress works" "yes" "no" ""
701 AC_DEFINE_UNQUOTED(CMK_DLL_USE_WIN32, $pass, [whether getProcAddress works])
702
703 fi    # end of skip_dl
704
705 #### check if socklen_t exists ####
706 cat > $t <<EOT
707 #include <sys/types.h>
708 #include <sys/socket.h>
709
710 void foo(void) {
711         int i;
712         socklen_t s=sizeof(i);
713 }
714 EOT
715 test_cxx "whether it has socklen_t" "yes" "no" ""
716 AC_DEFINE_UNQUOTED(CMK_HAS_SOCKLEN, $pass, [whether it has socklen_t])
717
718 #### check if mmap exists ####
719 cat > $t <<EOT
720 #include <sys/types.h>
721 #include <sys/mman.h>
722
723 void *foo(void *a,int l,int fd) {
724         return mmap((caddr_t)a,l,PROT_READ+PROT_WRITE,
725                  MAP_FIXED+MAP_PRIVATE,fd,0);
726 }
727 EOT
728 test_cxx "whether the mmap() syscall exists" "yes" "no" ""
729 AC_DEFINE_UNQUOTED(CMK_HAS_MMAP, $pass, [whether the mmap() syscall exists])
730
731 #### check if mmap accepts MAP_ANON ####
732 cat > $t <<EOT
733 #include <sys/types.h>
734 #include <sys/mman.h>
735
736 void *foo(void *a,int l) {
737         return mmap((caddr_t)a,l,PROT_READ+PROT_WRITE,
738                 MAP_FIXED+MAP_PRIVATE+MAP_ANON,-1,0);
739 }
740 EOT
741 test_cxx "whether mmap() accepts MAP_ANON" "yes" "no" ""
742 AC_DEFINE_UNQUOTED(CMK_HAS_MMAP_ANON, $pass, [whether mmap() accepts MAP_ANON])
743
744 #### check if get_myaddress exists ####
745 cat > $t <<EOT
746 #include <rpc/rpc.h>
747
748 void foo(void *a) {
749     get_myaddress((struct sockaddr_in*)a);
750 }
751 EOT
752 test_cxx "whether get_myaddress() exists" "yes" "no" ""
753 AC_DEFINE_UNQUOTED(CMK_HAS_GET_MYADDRESS, $pass, [whether get_myaddress() exists])
754
755 #### check if glibc backtrace exists ####
756 cat > $t <<EOT
757 #include "cmibacktrace.c"
758
759 int main() {
760         int nLevels=1;
761         void *stack;
762         CmiBacktraceRecord(&stack,0,&nLevels);
763         return 0;
764 }
765 EOT
766 TRACE_LINK_FLAG="-rdynamic"
767 test_link "whether glibc backtrace works" "yes" "no" "-DCMK_USE_BACKTRACE=1 $TRACE_LINK_FLAG"
768 AC_DEFINE_UNQUOTED(CMK_USE_BACKTRACE, $pass, [whether glibc backtrace works])
769
770 if test $strictpass -eq 1
771 then 
772         add_flag 'CMK_LD="$CMK_LD '$TRACE_LINK_FLAG'"' "backtrace"
773         add_flag 'CMK_LDXX="$CMK_LDXX '$TRACE_LINK_FLAG'"' "backtrace"
774 fi
775
776
777 #### test if has zlib ####
778 # bproc doesnot like -lz in any case
779 if test -z "$CMK_BPROC"
780 then
781
782 cat > $t <<EOT
783 #include <zlib.h>
784 int main() { 
785   gzFile f = gzopen("/tmp/x","r");
786   gzprintf(f, "test...\n");
787   gzclose(f);
788   return 0;
789 }
790 EOT
791 test_link "whether it has zlib" "yes" "no" "-lz"
792 AC_DEFINE_UNQUOTED(CMK_PROJECTIONS_USE_ZLIB, $pass, [whether it has zlib])
793 if test $pass -eq 1
794 then 
795         add_flag 'CMK_LIBZ="-lz"' "zlib"
796 fi
797
798 fi
799
800 ### test for libjpeg ####
801 cat > $tc <<EOT
802 #include <stdio.h>
803 #include <stdlib.h>
804 #include "jpeglib.h"
805
806 int main()
807 {
808   struct jpeg_compress_struct cinfo;
809   jpeg_create_compress(&cinfo);
810   return 0;
811 }
812 EOT
813 test_linkc "whether it has libjpeg" "yes" "no" "-ljpeg"
814 AC_DEFINE_UNQUOTED(CMK_USE_LIBJPEG, $pass, [whether it has libjpeg])
815 if test $pass -eq 1
816 then
817         add_flag 'CMK_LIBJPEG="-ljpeg"' "libjpeg"
818 fi
819
820 #### test if has values.h ####
821 cat > $t <<EOT
822 #include <values.h>
823 int main() { 
824   double d = MAXDOUBLE;
825   return 0;
826 }
827 EOT
828 test_cxx "whether has values.h " "yes" "no" ""
829 AC_DEFINE_UNQUOTED(CMK_HAS_VALUES_H, $pass, [whether has values.h])
830
831 #### test if has alloca.h ####
832 cat > $t <<EOT
833 #include <alloca.h>
834 int main() {
835   double *s=(double *)alloca(sizeof(double));
836   *s=1.0;
837   return 0;
838 }
839 EOT
840 test_cxx "whether has alloca.h " "yes" "no" ""
841 AC_DEFINE_UNQUOTED(CMK_HAS_ALLOCA_H, $pass, [whether has alloca.h])
842
843 #### test if has malloc.h ####
844 cat > $t <<EOT
845 #include <malloc.h>
846 int main() { 
847   return 0;
848 }
849 EOT
850 test_cxx "whether has malloc.h " "yes" "no" ""
851 AC_DEFINE_UNQUOTED(CMK_HAS_MALLOC_H, $pass, [whether has malloc.h])
852
853 #### test if has elf.h ####
854 cat > $t <<EOT
855 #include <elf.h>
856 typedef Elf32_Addr ELF_TYPE_Addr;
857 int main() { 
858 }
859 EOT
860 test_cxx "whether has elf.h " "yes" "no" ""
861 AC_DEFINE_UNQUOTED([CMK_HAS_ELF_H], $pass, [whether has elf.h])
862
863 #### test if has stdint.h ####
864 cat > $t <<EOT
865 #include <stdint.h>
866 int main() { 
867   return 0;
868 }
869 EOT
870 test_cxx "whether has stdint.h " "yes" "no" ""
871 AC_DEFINE_UNQUOTED(CMK_HAS_STDINT_H, $pass, [whether has stdint.h])
872
873 #### test if has Multiprocessing.h for apple ####
874 cat > $t <<EOT
875 #include <Carbon/Carbon.h>
876 #include <Multiprocessing.h>
877 int main() {
878   int a = MPProcessorsScheduled();
879 }
880 EOT
881 test_cxx "whether has Multiprocessing.h for Apple " "yes" "no" ""
882 AC_DEFINE_UNQUOTED([CMK_HAS_MULTIPROCESSING_H], $pass, [whether has Multiprocessing.h])
883
884 #### test if has stdint.h ####
885 cat > $t <<EOT
886 #include <stdint.h>
887 int main() {
888   return 0;
889 }
890 EOT
891 test_cxx "whether has stdint.h " "yes" "no" ""
892 AC_DEFINE_UNQUOTED(CMK_HAS_STDINT_H, $pass, [whether has stdint.h])
893
894 #### check if PAPI exists ####
895 if test -n "$CMK_USE_PAPI"
896 then
897 cat > $t <<EOT
898 #include <stdio.h>
899 #include <papi.h>
900                                                                                 
901 int main() {
902     int Events[[1]] = { PAPI_TOT_CYC };
903     if (PAPI_start_counters(Events, 1) != PAPI_OK) return 1;
904     return 0;
905 }
906 EOT
907 test_link "whether PAPI exists" "yes" "no" "-lpapi"
908 AC_DEFINE_UNQUOTED(CMK_HAS_COUNTER_PAPI, $pass, [whether PAPI exists])
909 if test $pass -eq 1
910 then 
911         add_flag 'CMK_LIBS="$CMK_LIBS -lpapi"' "papi"
912 fi
913 fi
914
915 #### test if Python headers are installed ####
916 PYTHON_VERSION=`python -V 2>&1 | awk {'print $2'} | awk -F. {'print $1"."$2'}`
917 cat > $t <<EOT
918 #include "python${PYTHON_VERSION}/Python.h"
919 #include "python${PYTHON_VERSION}/compile.h"
920 #include "python${PYTHON_VERSION}/eval.h"
921 #include "python${PYTHON_VERSION}/node.h"
922
923 int main() {
924     Py_Initialize();
925     PyEval_InitThreads();
926     struct _node* programNode = PyParser_SimpleParseString("return 1\n",Py_file_input);
927     PyCodeObject *program = PyNode_Compile(programNode, "");
928 }
929 EOT
930 test_link "whether Python is installed" "yes" "no" "-lpython$PYTHON_VERSION -lpthread -lutil -ldl"
931 AC_DEFINE_UNQUOTED(CMK_HAS_PYTHON, $pass, [whether Python is installed])
932 AC_DEFINE_UNQUOTED(CMK_PYTHON_VERSION, ${PYTHON_VERSION}, [Python version])
933 if test $pass -eq 1
934 then
935         add_flag "CMK_BUILD_PYTHON=$PYTHON_VERSION" "python"
936 fi
937
938 #### test if it can build shared library ####
939 cat > $t <<EOT
940 extern int foo();
941 int foo1() { 
942   foo();
943   return 0;
944 }
945 EOT
946 test_linkso "whether it can build shared library" "yes" "no" ""
947 if test $pass -eq 0
948 then 
949         add_flag 'CMK_NO_BUILD_SHARED="true"' "build-shared"
950 fi
951
952 #### test the version number of bproc ####
953 if test -n "$CMK_BPROC"
954 then
955 cat > $t <<EOT
956 #include <stdio.h>
957 #include <sys/bproc.h>
958 int main()
959 {
960   struct bproc_version_t vers;
961   bproc_version(&vers);
962   printf("%s\n", vers.version_string);
963 }
964 EOT
965 test_link "whether bproc compiles" "yes" "no" "-lbproc"
966 if test $pass -eq 1
967 then 
968 AC_MSG_CHECKING("bproc version")
969 bproc_ver=`./testlink`
970 test_result 0 "bproc version" "$bproc_ver" ""
971 bproc_ver=`echo $bproc_ver | cut -d'.' -f1`
972 AC_DEFINE_UNQUOTED(CMK_BPROC_VERSION, $bproc_ver, [bproc version])
973 fi
974 fi
975
976 #### test the if command sync exists ####
977 AC_CHECK_PROG(SYNC, sync, sync )
978 if test -n "$SYNC"
979 then
980 AC_DEFINE_UNQUOTED(CMK_HAS_SYNC, 1, [sync program])
981 fi
982
983 ################## Fortran #########################
984
985 #echo "set F77 compiler as: $CMK_CF77"
986 AC_MSG_CHECKING("F77 compiler as")
987 AC_MSG_RESULT("$CMK_CF77")
988
989 AC_MSG_CHECKING("whether Fortran 77 compiler works")
990 ### test fortran 77 compiler ###
991 cat > conftest.f <<EOF
992       SUBROUTINE FOO_foo
993       END
994 EOF
995 $CMK_CF77 -c conftest.f > /dev/null 2> /dev/null
996 if test ! -r conftest.o
997 then
998   AC_MSG_RESULT("no")
999 else
1000   AC_MSG_RESULT("yes")
1001 fi
1002
1003 ### test fortran 90 compiler ###
1004 #echo "set F90 compiler as: $CMK_CF90"
1005 AC_MSG_CHECKING("F90 compiler as")
1006 AC_MSG_RESULT("$CMK_CF90")
1007
1008 AC_MSG_CHECKING("whether Fortran 90 compiler works")
1009 cat > conftest2.f90 <<EOF
1010       SUBROUTINE FOO_foo
1011       END
1012 EOF
1013 $CMK_CF90 -c conftest2.f90 > /dev/null 2> /dev/null
1014 if test ! -r conftest2.o
1015 then
1016   AC_MSG_RESULT("no")
1017 else
1018   AC_MSG_RESULT("yes")
1019   mv -f conftest2.o conftest.o
1020   USE_FORTRAN90=1
1021 fi
1022
1023 ### check fortran name mangling
1024 AC_MSG_CHECKING(subroutine name used by Fortran 90 compiler)
1025
1026 if test -r conftest.o
1027 then
1028   AC_CACHE_VAL(fortran_postfix,
1029
1030   NAME=`$CMK_NM conftest.o | grep "foo_foo__"`
1031   if test "$NAME" != ""
1032   then
1033     fortran_postfix=TWOSCORE
1034     AC_DEFINE_UNQUOTED(CMK_FORTRAN_USES_TWOSCORE, 1, [TWOSCORE])
1035   else
1036     NAME=`$CMK_NM conftest.o | grep "foo_foo_"`
1037     if test "$NAME" != ""
1038     then
1039       fortran_postfix=ONESCORE
1040       AC_DEFINE_UNQUOTED(CMK_FORTRAN_USES_ONESCORE, 1, [ONESCORE])
1041     else
1042       NAME=`$CMK_NM conftest.o | grep "foo_foo"`
1043       if test "$NAME" != ""
1044       then
1045         fortran_postfix=NOSCORE
1046         AC_DEFINE_UNQUOTED(CMK_FORTRAN_USES_NOSCORE, 1, [NOSCORE])
1047       else
1048         NAME=`$CMK_NM conftest.o | grep "FOO_FOO"`
1049         if test "$NAME" != ""
1050         then
1051           fortran_postfix=ALLCAPS
1052           AC_DEFINE_UNQUOTED(CMK_FORTRAN_USES_ALLCAPS, 1, [ALLCAPS])
1053         else
1054           echo "#################################################"
1055           echo "FORTRAN compiler generated name not supported yet"
1056           echo "#################################################"
1057         fi
1058       fi
1059     fi
1060   fi
1061   rm -f conftest.f conftest.o
1062   )
1063   AC_MSG_RESULT($fortran_postfix)
1064 else
1065   AC_MSG_RESULT("Fortran compiler not working")
1066 fi
1067
1068 ### check module name ###
1069
1070 if test "$USE_FORTRAN90" = 1
1071 then
1072   cat > conftest.f90 <<EOF
1073       MODULE testmod
1074         interface 
1075           function fpup_issizing(p)
1076           INTEGER :: p
1077           logical fpup_issizing
1078           end function
1079         end interface
1080       END MODULE
1081 EOF
1082   AC_MSG_CHECKING(Fortran 90 mod name is capital)
1083   $CMK_CF90 -c conftest.f90 > /dev/null 2> /dev/null
1084   name=`ls TESTMOD.* 2>/dev/null`
1085   if test -n "$name"
1086   then
1087         AC_MSG_RESULT("yes")
1088         add_flag 'CMK_MOD_NAME_ALLCAPS=1' "mod name capital"
1089   else
1090         AC_MSG_RESULT("no")
1091         name=`ls testmod.* 2>/dev/null`
1092   fi
1093   if test -n "$name"
1094   then
1095         AC_MSG_CHECKING(Fortran 90 mod name extension)
1096         ext=`echo $name | sed -e 's/^[[^.]]*\.//'`
1097         add_flag 'CMK_MOD_EXT="'$ext'"' "mod name extension"
1098         AC_MSG_RESULT("$ext")
1099         /bin/rm -f $name
1100   fi
1101   /bin/rm -f conftest.f90
1102 fi
1103
1104 ### go get libpthread.a from charm website ###
1105 if test "$base_version" = "net-linux" || test "$base_version" = "mpi-linux"
1106 then
1107 case $version in
1108 *linux*smp*|*linux*vmi*)
1109   if test ! -r ../lib/libpthread.a
1110   then
1111     AC_CHECK_PROG(WGET, wget, wget )
1112     AC_CHECK_PROG(LYNX, lynx, lynx )
1113     AC_CHECK_PROG(TELNET, telnet, telnet )
1114     AC_CHECK_PROG(UUDECODE, uudecode, uudecode )
1115     
1116     CHARMIP='128.174.241.81'
1117 #    CHARMIP='charm.cs.uiuc.edu'
1118 #    VERSION=`nm /lib/libc.so.6 | grep "A GLIBC_" | tail -1 | sed -e "s/00000000 A GLIBC_//g"`
1119     AC_MSG_CHECKING(glibc version)
1120     get_glibc_version
1121     AC_MSG_RESULT($GLIBCVERSION)
1122     if test 1 = `expr $GLIBCVERSION \> 2.2.92` 
1123     then
1124       cat >> ./conv-mach-opt.h << EOT
1125 #undef CMK_LINUX_PTHREAD_HACK
1126 EOT
1127     else
1128       L="libpthread-$GLIBCVERSION.a"
1129       LSO="libpthread-$GLIBCVERSION.so"
1130       URL="http://${CHARMIP}/distrib/$L"
1131       URLSO="http://${CHARMIP}/distrib/$LSO"
1132       finish=0
1133       printf "getting $L from $URL ..."
1134       if test -n "$WGET"
1135       then
1136         printf "(wget) ..."
1137         $WGET $URL > /dev/null 2>&1  && mv $L ../lib && finish=1
1138         $WGET $URLSO > /dev/null 2>&1  && mv $LSO ../lib_so
1139       fi
1140       if test $finish = 0 && test -n "$LYNX"
1141       then
1142         printf "(lynx) ..."
1143         $LYNX -source $URL > $L 2>/dev/null 
1144         if file -L $L | grep 'archive' > /dev/null
1145         then
1146           mv $L ../lib && finish=1
1147         fi
1148         $LYNX -source $URLSO > $L 2>/dev/null 
1149       fi
1150       if test $finish = 0 && test -n "$TELNET" && test -n "$UUDECODE"
1151       then
1152         printf "(telnet) ..."
1153         cat > get_libpthread <<EOT
1154 #! /bin/sh
1155 echo "GET /distrib/libpthread-$GLIBCVERSION.uu 1.0"
1156 echo
1157 # exit normally when the telnet session closes.
1158 trap "exit 0" 13
1159 while : ; do
1160  echo
1161  sleep 1
1162 done
1163 EOT
1164         /bin/sh ./get_libpthread | ($TELNET $CHARMIP 80 > .uulib 2>/dev/null); $UUDECODE .uulib 2>/dev/null && rm -f .uulib && mv $L ../lib && finish=1
1165       fi
1166       ln -s $L ../lib/libpthread.a
1167       ln -s $LSO ../lib_so/libpthread.so
1168       if test $finish = 0 || test ! -r ../lib/libpthread.a
1169       then
1170         /bin/rm -f ../lib/libpthread.a
1171         echo "failed"
1172         echo "#####################################################################"
1173         echo "wget, lynx or telnet must be installed to get libpthread.a from charm website."
1174         echo "Alternately, your version of GLIBC ($GLIBCVERSION) is not yet supported--"
1175         echo " contact ppl@cs.uiuc.edu for assistance."
1176         echo "#####################################################################"
1177         exit 1
1178       else
1179         echo "done"
1180       fi
1181     fi
1182   fi
1183   ;;
1184 esac
1185 fi
1186
1187 AC_OUTPUT(
1188 libs/ck-libs/ampi/ampirun,
1189
1190 chmod +x libs/ck-libs/ampi/ampirun
1191 )