de3a06aa8edc556e8c17f5ae8b9ec6c57e94366c
[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 $? -ne 0
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 $? -ne 0
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 if has values.h ####
801 cat > $t <<EOT
802 #include <values.h>
803 int main() { 
804   double d = MAXDOUBLE;
805   return 0;
806 }
807 EOT
808 test_cxx "whether has values.h " "yes" "no" ""
809 AC_DEFINE_UNQUOTED(CMK_HAS_VALUES_H, $pass, [whether has values.h])
810
811 #### test if has alloca.h ####
812 cat > $t <<EOT
813 #include <alloca.h>
814 int main() {
815   double *s=(double *)alloca(sizeof(double));
816   *s=1.0;
817   return 0;
818 }
819 EOT
820 test_cxx "whether has alloca.h " "yes" "no" ""
821 AC_DEFINE_UNQUOTED(CMK_HAS_ALLOCA_H, $pass, [whether has alloca.h])
822
823 #### test if has malloc.h ####
824 cat > $t <<EOT
825 #include <malloc.h>
826 int main() { 
827   return 0;
828 }
829 EOT
830 test_cxx "whether has malloc.h " "yes" "no" ""
831 AC_DEFINE_UNQUOTED(CMK_HAS_MALLOC_H, $pass, [whether has malloc.h])
832
833 #### test if has elf.h ####
834 cat > $t <<EOT
835 #include <elf.h>
836 typedef Elf32_Addr ELF_TYPE_Addr;
837 int main() { 
838 }
839 EOT
840 test_cxx "whether has elf.h " "yes" "no" ""
841 AC_DEFINE_UNQUOTED([CMK_HAS_ELF_H], $pass, [whether has elf.h])
842
843 #### test if has stdint.h ####
844 cat > $t <<EOT
845 #include <stdint.h>
846 int main() { 
847   return 0;
848 }
849 EOT
850 test_cxx "whether has stdint.h " "yes" "no" ""
851 AC_DEFINE_UNQUOTED(CMK_HAS_STDINT_H, $pass, [whether has stdint.h])
852
853 #### test if has Multiprocessing.h for apple ####
854 cat > $t <<EOT
855 #include <Carbon/Carbon.h>
856 #include <Multiprocessing.h>
857 int main() {
858   int a = MPProcessorsScheduled();
859 }
860 EOT
861 test_cxx "whether has Multiprocessing.h for Apple " "yes" "no" ""
862 AC_DEFINE_UNQUOTED([CMK_HAS_MULTIPROCESSING_H], $pass, [whether has Multiprocessing.h])
863
864 #### test if has stdint.h ####
865 cat > $t <<EOT
866 #include <stdint.h>
867 int main() {
868   return 0;
869 }
870 EOT
871 test_cxx "whether has stdint.h " "yes" "no" ""
872 AC_DEFINE_UNQUOTED(CMK_HAS_STDINT_H, $pass, [whether has stdint.h])
873
874 #### test if "ntohl" is available ####
875 cat > $t <<EOT
876 #include "converse.h"
877 #if defined(_WIN32) && ! defined(__CYGWIN__)
878 #include <winsock.h>
879 #else
880 #include <netinet/in.h>
881 #include <arpa/inet.h>
882 #endif
883
884 int main() {
885   int i = 100;
886   i = ntohl(i);
887   return 0;
888 }
889 EOT
890 test_link "whether ntohl is available" "yes" "no" ""
891 AC_DEFINE_UNQUOTED(CMK_HAS_NTOHL, $pass, [whether ntohl is available])
892
893 ### test for libjpeg ####
894 cat > $t <<EOT
895 #include <stdio.h>
896 #include <stdlib.h>
897 #include "converse.h"    /* cygwin does not like this */
898 #include "jpeglib.h"
899
900 int main()
901 {
902   struct jpeg_compress_struct cinfo;
903   jpeg_create_compress(&cinfo);
904   return 0;
905 }
906 EOT
907 test_link "whether it has libjpeg" "yes" "no" "-ljpeg"
908 AC_DEFINE_UNQUOTED(CMK_USE_LIBJPEG, $pass, [whether it has libjpeg])
909 if test $pass -eq 1
910 then
911         add_flag 'CMK_LIBJPEG="-ljpeg"' "libjpeg"
912 fi
913
914 #### check if PAPI exists ####
915 if test -n "$CMK_USE_PAPI"
916 then
917 cat > $t <<EOT
918 #include <stdio.h>
919 #include <papi.h>
920                                                                                 
921 int main() {
922     int Events[[1]] = { PAPI_TOT_CYC };
923     if (PAPI_start_counters(Events, 1) != PAPI_OK) return 1;
924     return 0;
925 }
926 EOT
927 test_link "whether PAPI exists" "yes" "no" "-lpapi"
928 AC_DEFINE_UNQUOTED(CMK_HAS_COUNTER_PAPI, $pass, [whether PAPI exists])
929 if test $pass -eq 1
930 then 
931         add_flag 'CMK_LIBS="$CMK_LIBS -lpapi"' "papi"
932 fi
933 fi
934
935 #### test if Python headers are installed ####
936 PYTHON_VERSION=`python -V 2>&1 | awk {'print $2'} | awk -F. {'print $1"."$2'}`
937 cat > $t <<EOT
938 #include "python${PYTHON_VERSION}/Python.h"
939 #include "python${PYTHON_VERSION}/compile.h"
940 #include "python${PYTHON_VERSION}/eval.h"
941 #include "python${PYTHON_VERSION}/node.h"
942
943 int main() {
944     Py_Initialize();
945     PyEval_InitThreads();
946     struct _node* programNode = PyParser_SimpleParseString("return 1\n",Py_file_input);
947     PyCodeObject *program = PyNode_Compile(programNode, "");
948 }
949 EOT
950 test_link "whether Python is installed" "yes" "no" "-lpython$PYTHON_VERSION -lpthread -lutil -ldl"
951 AC_DEFINE_UNQUOTED(CMK_HAS_PYTHON, $pass, [whether Python is installed])
952 AC_DEFINE_UNQUOTED(CMK_PYTHON_VERSION, ${PYTHON_VERSION}, [Python version])
953 if test $pass -eq 1
954 then
955         add_flag "CMK_BUILD_PYTHON=$PYTHON_VERSION" "python"
956 fi
957
958 #### test if it can build shared library ####
959 cat > $t <<EOT
960 extern int foo();
961 int foo1() { 
962   foo();
963   return 0;
964 }
965 EOT
966 test_linkso "whether it can build shared library" "yes" "no" ""
967 if test $pass -eq 0
968 then 
969         add_flag 'CMK_NO_BUILD_SHARED="true"' "build-shared"
970 fi
971
972 #### test the version number of bproc ####
973 if test -n "$CMK_BPROC"
974 then
975 cat > $t <<EOT
976 #include <stdio.h>
977 #include <sys/bproc.h>
978 int main()
979 {
980   struct bproc_version_t vers;
981   bproc_version(&vers);
982   printf("%s\n", vers.version_string);
983 }
984 EOT
985 test_link "whether bproc compiles" "yes" "no" "-lbproc"
986 if test $pass -eq 1
987 then 
988 AC_MSG_CHECKING("bproc version")
989 bproc_ver=`./testlink`
990 test_result 0 "bproc version" "$bproc_ver" ""
991 bproc_ver=`echo $bproc_ver | cut -d'.' -f1`
992 AC_DEFINE_UNQUOTED(CMK_BPROC_VERSION, $bproc_ver, [bproc version])
993 fi
994 fi
995
996 #### test the if command sync exists ####
997 AC_CHECK_PROG(SYNC, sync, sync )
998 if test -n "$SYNC"
999 then
1000 AC_DEFINE_UNQUOTED(CMK_HAS_SYNC, 1, [sync program])
1001 fi
1002
1003 ################## Fortran #########################
1004
1005 #echo "set F77 compiler as: $CMK_CF77"
1006 AC_MSG_CHECKING("F77 compiler as")
1007 AC_MSG_RESULT("$CMK_CF77")
1008
1009 AC_MSG_CHECKING("whether Fortran 77 compiler works")
1010 ### test fortran 77 compiler ###
1011 cat > conftest.f <<EOF
1012       SUBROUTINE FOO_foo
1013       END
1014 EOF
1015 $CMK_CF77 -c conftest.f > /dev/null 2> /dev/null
1016 if test ! -r conftest.o
1017 then
1018   AC_MSG_RESULT("no")
1019 else
1020   AC_MSG_RESULT("yes")
1021 fi
1022
1023 ### test fortran 90 compiler ###
1024 #echo "set F90 compiler as: $CMK_CF90"
1025 AC_MSG_CHECKING("F90 compiler as")
1026 AC_MSG_RESULT("$CMK_CF90")
1027
1028 AC_MSG_CHECKING("whether Fortran 90 compiler works")
1029 cat > conftest2.f90 <<EOF
1030       SUBROUTINE FOO_foo
1031       END
1032 EOF
1033 $CMK_CF90 -c conftest2.f90 > /dev/null 2> /dev/null
1034 if test ! -r conftest2.o
1035 then
1036   AC_MSG_RESULT("no")
1037 else
1038   AC_MSG_RESULT("yes")
1039   mv -f conftest2.o conftest.o
1040   USE_FORTRAN90=1
1041 fi
1042
1043 ### check fortran name mangling
1044 AC_MSG_CHECKING(subroutine name used by Fortran 90 compiler)
1045
1046 if test -r conftest.o
1047 then
1048   AC_CACHE_VAL(fortran_postfix,
1049
1050   NAME=`$CMK_NM conftest.o | grep "foo_foo__"`
1051   if test "$NAME" != ""
1052   then
1053     fortran_postfix=TWOSCORE
1054     AC_DEFINE_UNQUOTED(CMK_FORTRAN_USES_TWOSCORE, 1, [TWOSCORE])
1055   else
1056     NAME=`$CMK_NM conftest.o | grep "foo_foo_"`
1057     if test "$NAME" != ""
1058     then
1059       fortran_postfix=ONESCORE
1060       AC_DEFINE_UNQUOTED(CMK_FORTRAN_USES_ONESCORE, 1, [ONESCORE])
1061     else
1062       NAME=`$CMK_NM conftest.o | grep "foo_foo"`
1063       if test "$NAME" != ""
1064       then
1065         fortran_postfix=NOSCORE
1066         AC_DEFINE_UNQUOTED(CMK_FORTRAN_USES_NOSCORE, 1, [NOSCORE])
1067       else
1068         NAME=`$CMK_NM conftest.o | grep "FOO_FOO"`
1069         if test "$NAME" != ""
1070         then
1071           fortran_postfix=ALLCAPS
1072           AC_DEFINE_UNQUOTED(CMK_FORTRAN_USES_ALLCAPS, 1, [ALLCAPS])
1073         else
1074           echo "#################################################"
1075           echo "FORTRAN compiler generated name not supported yet"
1076           echo "#################################################"
1077         fi
1078       fi
1079     fi
1080   fi
1081   rm -f conftest.f conftest.o
1082   )
1083   AC_MSG_RESULT($fortran_postfix)
1084 else
1085   AC_MSG_RESULT("Fortran compiler not working")
1086 fi
1087
1088 ### check module name ###
1089
1090 if test "$USE_FORTRAN90" = 1
1091 then
1092   cat > conftest.f90 <<EOF
1093       MODULE testmod
1094         interface 
1095           function fpup_issizing(p)
1096           INTEGER :: p
1097           logical fpup_issizing
1098           end function
1099         end interface
1100       END MODULE
1101 EOF
1102   AC_MSG_CHECKING(Fortran 90 mod name is capital)
1103   $CMK_CF90 -c conftest.f90 > /dev/null 2> /dev/null
1104   name=`ls TESTMOD.* 2>/dev/null`
1105   if test -n "$name"
1106   then
1107         AC_MSG_RESULT("yes")
1108         add_flag 'CMK_MOD_NAME_ALLCAPS=1' "mod name capital"
1109   else
1110         AC_MSG_RESULT("no")
1111         name=`ls testmod.* 2>/dev/null`
1112   fi
1113   if test -n "$name"
1114   then
1115         AC_MSG_CHECKING(Fortran 90 mod name extension)
1116         ext=`echo $name | sed -e 's/^[[^.]]*\.//'`
1117         add_flag 'CMK_MOD_EXT="'$ext'"' "mod name extension"
1118         AC_MSG_RESULT("$ext")
1119         /bin/rm -f $name
1120   fi
1121   /bin/rm -f conftest.f90
1122 fi
1123
1124 ### go get libpthread.a from charm website ###
1125 if test "$base_version" = "net-linux" || test "$base_version" = "mpi-linux"
1126 then
1127 case $version in
1128 *linux*smp*|*linux*vmi*)
1129   if test ! -r ../lib/libpthread.a
1130   then
1131     AC_CHECK_PROG(WGET, wget, wget )
1132     AC_CHECK_PROG(LYNX, lynx, lynx )
1133     AC_CHECK_PROG(TELNET, telnet, telnet )
1134     AC_CHECK_PROG(UUDECODE, uudecode, uudecode )
1135     
1136     CHARMIP='128.174.241.81'
1137 #    CHARMIP='charm.cs.uiuc.edu'
1138 #    VERSION=`nm /lib/libc.so.6 | grep "A GLIBC_" | tail -1 | sed -e "s/00000000 A GLIBC_//g"`
1139     AC_MSG_CHECKING(glibc version)
1140     get_glibc_version
1141     AC_MSG_RESULT($GLIBCVERSION)
1142     if test 1 = `expr $GLIBCVERSION \> 2.2.92` 
1143     then
1144       cat >> ./conv-mach-opt.h << EOT
1145 #undef CMK_LINUX_PTHREAD_HACK
1146 EOT
1147     else
1148       L="libpthread-$GLIBCVERSION.a"
1149       LSO="libpthread-$GLIBCVERSION.so"
1150       URL="http://${CHARMIP}/distrib/$L"
1151       URLSO="http://${CHARMIP}/distrib/$LSO"
1152       finish=0
1153       printf "getting $L from $URL ..."
1154       if test -n "$WGET"
1155       then
1156         printf "(wget) ..."
1157         $WGET $URL > /dev/null 2>&1  && mv $L ../lib && finish=1
1158         $WGET $URLSO > /dev/null 2>&1  && mv $LSO ../lib_so
1159       fi
1160       if test $finish = 0 && test -n "$LYNX"
1161       then
1162         printf "(lynx) ..."
1163         $LYNX -source $URL > $L 2>/dev/null 
1164         if file -L $L | grep 'archive' > /dev/null
1165         then
1166           mv $L ../lib && finish=1
1167         fi
1168         $LYNX -source $URLSO > $L 2>/dev/null 
1169       fi
1170       if test $finish = 0 && test -n "$TELNET" && test -n "$UUDECODE"
1171       then
1172         printf "(telnet) ..."
1173         cat > get_libpthread <<EOT
1174 #! /bin/sh
1175 echo "GET /distrib/libpthread-$GLIBCVERSION.uu 1.0"
1176 echo
1177 # exit normally when the telnet session closes.
1178 trap "exit 0" 13
1179 while : ; do
1180  echo
1181  sleep 1
1182 done
1183 EOT
1184         /bin/sh ./get_libpthread | ($TELNET $CHARMIP 80 > .uulib 2>/dev/null); $UUDECODE .uulib 2>/dev/null && rm -f .uulib && mv $L ../lib && finish=1
1185       fi
1186       ln -s $L ../lib/libpthread.a
1187       ln -s $LSO ../lib_so/libpthread.so
1188       if test $finish = 0 || test ! -r ../lib/libpthread.a
1189       then
1190         /bin/rm -f ../lib/libpthread.a
1191         echo "failed"
1192         echo "#####################################################################"
1193         echo "wget, lynx or telnet must be installed to get libpthread.a from charm website."
1194         echo "Alternately, your version of GLIBC ($GLIBCVERSION) is not yet supported--"
1195         echo " contact ppl@cs.uiuc.edu for assistance."
1196         echo "#####################################################################"
1197         exit 1
1198       else
1199         echo "done"
1200       fi
1201     fi
1202   fi
1203   ;;
1204 esac
1205 fi
1206
1207 AC_OUTPUT(
1208 libs/ck-libs/ampi/ampirun,
1209
1210 chmod +x libs/ck-libs/ampi/ampirun
1211 )