25e3cccea058653754dbd92d65e2eb97eb20115c
[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=60301
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         echo "### $1" >> $charmout
60         cat $tc >> $charmout
61         echo $CMK_CC -I../include -I. $CMK_LIBDIR $CMK_INCDIR $OPTS_CC $OPTS_LD -c $tc -o test.o $4 >> $charmout
62         $CMK_CC -I../include -I. $CMK_LIBDIR $CMK_INCDIR $OPTS_CC $OPTS_LD -c $tc -o test.o $4 > out 2>&1
63         test_result $? "$1" "$2" "$3"
64         strictpass=$pass
65         strictfail=$fail
66         if test $pass -eq 1
67         then 
68           if cat out | grep -i "warn" > /dev/null 2>&1
69           then 
70             strictpass="0" && strictfail="1"
71           fi
72         fi
73         cat out >> $charmout
74         /bin/rm -f out
75 }
76
77 # Test: tries to compile C++ file $t (described by $1).
78 #  If successful, prints $2 and sets $pass/clears $fail
79 #  If failure, prints $3 and sets $pass/clears $fail
80 #  additional arguments to c++ compiler are passed as $4
81 test_cxx() {
82         AC_MSG_CHECKING("$1")
83         echo "### $1" >> $charmout
84         cat $t >> $charmout
85         echo $CMK_CXX -I../include -I. $CMK_LIBDIR $CMK_INCDIR $OPTS_CXX $OPTS_LD -c $t -o test.o $4 >> $charmout
86         $CMK_CXX -I../include -I. $CMK_LIBDIR $CMK_INCDIR $OPTS_CXX $OPTS_LD -c $t -o test.o $4 > out 2>&1
87         test_result $? "$1" "$2" "$3"
88         strictpass=$pass
89         strictfail=$fail
90         if test $pass -eq 1
91         then 
92           if cat out | grep -i "warn" > /dev/null 2>&1
93           then 
94             strictpass="0" && strictfail="1"
95           fi
96         fi
97         cat out >> $charmout
98         /bin/rm -f out
99 }
100
101 # Testlink: tries to compile and link a C++ file $t (described by $1).
102 #  If successful, prints $2 and sets $pass/clears $fail
103 #  If failure, prints $3 and sets $pass/clears $fail
104 #  additional arguments to c++ compiler are passed as $4
105 test_link() {
106         AC_MSG_CHECKING("$1")
107         echo "### $1" >> $charmout
108         cat $t >> $charmout
109         echo $CMK_CXX -I../include -I. $CMK_INCDIR $OPTS_CXX -c $t -o test.o $4 >> $charmout
110         $CMK_CXX -I../include -I. $CMK_INCDIR $OPTS_CXX -c $t -o test.o $4 > out 2>&1
111         if test $? -ne 0
112         then
113           test_result 1 "$1" "$2" "$3"
114         else
115           echo $CMK_LDXX -o testlink test.o $CMK_LIBDIR $OPTS_LD $CMK_SYSLIBS $4 >> $charmout
116           $CMK_LDXX -o testlink test.o $CMK_LIBDIR $OPTS_LD $CMK_SYSLIBS $4 >> out 2>&1
117           ret=$?
118           test ! -x testlink && ret=1
119           test_result $ret "$1" "$2" "$3"
120         fi
121         strictpass=$pass
122         strictfail=$fail
123         if test $pass -eq 1
124         then 
125           if cat out | grep -i "warn" > /dev/null 2>&1
126           then 
127             strictpass="0" && strictfail="1"
128           fi
129         fi
130         cat out >> $charmout
131         /bin/rm -f out
132 }
133
134 # Testlinkc: tries to compile and link a C file $t (described by $1).
135 #  If successful, prints $2 and sets $pass/clears $fail
136 #  If failure, prints $3 and sets $pass/clears $fail
137 #  additional arguments to c++ compiler are passed as $4
138 test_linkc() {
139         AC_MSG_CHECKING("$1")
140         echo "### $1" >> $charmout
141         cat $tc >> $charmout
142         echo $CMK_CC -I../include -I. $CMK_INCDIR $OPTS_CC -c $tc -o test.o $4 >> $charmout
143         $CMK_CC -I../include -I. $CMK_INCDIR $OPTS_CC -c $tc -o test.o $4 > out 2>&1
144         if test $? -ne 0
145         then
146           test_result 1 "$1" "$2" "$3"
147         else
148           echo $CMK_LD -o testlink test.o $CMK_LIBDIR $OPTS_LD $CMK_SYSLIBS $4 >> $charmout
149           $CMK_LD -o testlink test.o $CMK_LIBDIR $OPTS_LD $CMK_SYSLIBS $4 >> out 2>&1
150           test_result $? "$1" "$2" "$3"
151         fi
152         strictpass=$pass
153         strictfail=$fail
154         if test $pass -eq 1
155         then 
156           if cat out | grep -i "warn" > /dev/null 2>&1
157           then 
158             strictpass="0" && strictfail="1"
159           fi
160         fi
161         cat out >> $charmout
162         /bin/rm -f out
163 }
164
165 # test_linkso $1 $2 $3 $4, where
166 # $1: debug msg
167 # $2: yes msg
168 # $3: no msg
169 # $4: extra link option
170 test_linkso() {
171         AC_MSG_CHECKING("$1")
172         echo $1 >> $charmout
173         cat $t >> $charmout
174         echo $CMK_CXX -I../include -I. $CMK_INCDIR $OPTS_CXX -c $t -o test.o $4 >> $charmout
175         $CMK_CXX -I../include -I. $CMK_INCDIR $OPTS_CXX -c $t -o test.o $4 > out 2>&1
176         if test $? = 1
177         then
178           test_result 1 "$1" "$2" "$3"
179         else
180           echo $CMK_LD -I../include -I. $CMK_LIBDIR $OPTS_LD $CMK_LD_SHARED test.o -o testlink.$CMK_SHARED_SUF $4 >> $charmout
181           $CMK_LD -I../include -I. $CMK_LIBDIR $OPTS_LD $CMK_LD_SHARED test.o -o testlink.$CMK_SHARED_SUF $4 > out 2>&1
182           test_result $? "$1" "$2" "$3"
183         fi
184         cat out >> $charmout
185         /bin/rm -f out testlink.$CMK_SHARED_SUF
186 }
187
188 # add into conv-mach-opt.sh
189 # add_flag $1 $2
190 # $2 is description
191 add_flag() {
192         key=`echo $1 | cut -d'=' -f1`
193         last=`grep $key ../include/conv-mach-opt.sh 2>/dev/null | tail -1`
194         skip=0
195         if test -n "$last" -a  "$last" = "$1" 
196         then
197           skip=1
198         fi
199         if test $skip = 0
200         then
201           cat >> ../include/conv-mach-opt.sh << EOT
202
203 # Option added by configure script's $2 section
204 $1
205
206 EOT
207         fi
208 }
209
210 test_finish() {
211         rm -f $t $tc testlink test.o    > /dev/null 2>&1
212         /bin/rm -f out
213         exit $1
214 }
215
216 # try to decide the version of glibc
217 get_glibc_version() {
218 t=test.c
219 cat > $t <<EOT
220 #include <stdio.h>
221 #include <gnu/libc-version.h>
222 int main (void) { puts (gnu_get_libc_version ()); return 0; }
223 EOT
224 gcc -o gver test.c
225 GLIBCVERSION=`./gver`
226 /bin/rm -f $t gver
227 }
228
229 cat > $t <<EOT
230 #include <stdio.h>
231 void foo(void) {
232         printf("Hello, world!\n");
233 }
234 EOT
235 #echo "set C++ compiler as: $CMK_CXX $OPTS_CXX $OPTS"
236 AC_MSG_CHECKING("C++ compiler as")
237 AC_MSG_RESULT("$CMK_CXX $OPTS_CXX $OPTS")
238 test_cxx "whether C++ compiler works" "ok" "no" ""
239 if test $fail -eq 1
240 then
241         echo "Cannot compile C++ programs with $CMK_CXX"
242         echo " (check your charm++ version)"
243         test_finish 1
244 fi
245
246 cat > $t <<EOT
247 #include <stdio.h>
248 int main() {
249         printf("Hello, world!\n");
250         return 0;
251 }
252 EOT
253 #echo "set C++ linker as: $CMK_LDXX $OPTS_LDXX"
254 AC_MSG_CHECKING("C++ linker as")
255 AC_MSG_RESULT("$CMK_LDXX $OPTS_LDXX")
256 test_link "whether linker works" "ok" "no" ""
257 if test $fail -eq 1
258 then
259         echo "Cannot link C++ programs with $CMK_LDXX"
260         echo " (check your charm++ version)"
261         test_finish 1
262 fi
263
264 if test "$base_version" = "net-linux" 
265 then
266   test_link "whether linker accept --allow-multiple-definition" "ok" "no" "-Wl,--allow-multiple-definition"
267   if test $pass -eq 1
268   then
269         add_flag CMK_LDXX='"$CMK_LDXX -Wl,--allow-multiple-definition"' "net-linux linker"
270   fi
271 fi
272
273 # Perform the tests
274
275 #### Check if compiler if 64 bit ####
276 cat > $t <<EOT
277 #include <stdio.h>
278
279 int foo()
280 {
281 int x[[sizeof(void *) - 7]]={0};
282 return x[[0]];
283 }
284 EOT
285 test_cxx "whether compiler is 64bit" "yes" "no" ""
286 AC_DEFINE_UNQUOTED(CMK_SIZET_64BIT, $strictpass, [whether size_t 64bit])
287
288
289 #### check strings.h ####
290 cat > $t <<EOT
291 #include <strings.h>
292 int main() { 
293   char str[[8]];
294   bzero(str, 8);
295   return 0;
296 }
297 EOT
298 test_cxx "whether has strings.h " "yes" "no" ""
299 AC_DEFINE_UNQUOTED(CMK_HAS_STRINGS_H, $pass, [whether has strings.h])
300
301 #### test if has values.h ####
302 cat > $t <<EOT
303 #include <values.h>
304 int main() { 
305   double d = MAXDOUBLE;
306   return 0;
307 }
308 EOT
309 test_cxx "whether has values.h " "yes" "no" ""
310 AC_DEFINE_UNQUOTED(CMK_HAS_VALUES_H, $pass, [whether has values.h])
311
312 #### test if has stdint.h ####
313 cat > $t <<EOT
314 #include <stdint.h>
315 int main() { 
316   return 0;
317 }
318 EOT
319 test_cxx "whether has stdint.h " "yes" "no" ""
320 AC_DEFINE_UNQUOTED(CMK_HAS_STDINT_H, $pass, [whether has stdint.h])
321
322 #### test if has malloc.h ####
323 cat > $t <<EOT
324 #include <malloc.h>
325 int main() { 
326   return 0;
327 }
328 EOT
329 test_cxx "whether has malloc.h " "yes" "no" ""
330 AC_DEFINE_UNQUOTED(CMK_HAS_MALLOC_H, $pass, [whether has malloc.h])
331
332 #### test if has alloca.h ####
333 cat > $t <<EOT
334 #include <alloca.h>
335 int main() {
336   double *s=(double *)alloca(sizeof(double));
337   *s=1.0;
338   return 0;
339 }
340 EOT
341 test_cxx "whether has alloca.h " "yes" "no" ""
342 AC_DEFINE_UNQUOTED(CMK_HAS_ALLOCA_H, $pass, [whether has alloca.h])
343
344 #### test if has regex.h ####
345 cat > $t <<EOT
346 #include <regex.h>
347 int main() {
348   regex_t re;
349   regcomp(&re, ".*MOD.*", REG_EXTENDED|REG_NOSUB);
350   return 0;
351 }
352 EOT
353 test_cxx "whether has regex.h " "yes" "no" ""
354 AC_DEFINE_UNQUOTED(CMK_HAS_REGEX_H, $pass, [whether has regex.h])
355
356 #### Check bool ####
357 cat > $t <<EOT
358 #include <stdlib.h>
359 bool foo(void) { return true; }
360 EOT
361 test_cxx "whether C++ bool works" "ok" "no" ""
362 AC_DEFINE_UNQUOTED(CMK_BOOL_DEFINED, $pass, [whether C++ bool works])
363
364 #### Check long long ####
365 cat > $t <<EOT
366 #include <stdlib.h>
367 long long foo(void) { return 17; }
368 EOT
369 test_cxx "whether long long works" "ok" "no" ""
370 AC_DEFINE_UNQUOTED(CMK_LONG_LONG_DEFINED, $pass, [whether long long works])
371
372 #### Check __int64 ####
373 cat > $t <<EOT
374 #include <stdlib.h>
375 __int64 foo(void) { return 17; }
376 EOT
377 test_cxx "whether __int64 works" "ok" "no" ""
378 AC_DEFINE_UNQUOTED([CMK___int64_DEFINED], $pass, [whether __int64 works])
379
380 #### Check long double ####
381 cat > $t <<EOT
382 #include <stdlib.h>
383 long double foo(void) { return 17.0; }
384 EOT
385 test_cxx "whether long double works" "ok" "no" ""
386 AC_DEFINE_UNQUOTED(CMK_LONG_DOUBLE_DEFINED, $strictpass, [whether long double works])
387
388 #### Check ucontext and FPU pointer ####
389 cat > $t <<EOT
390 #include <ucontext.h>
391 struct _libc_fpstate   fpstate;
392 fpregset_t *fp;
393 EOT
394 test_cxx "whether ucontext has FPU pointer" "yes" "no" ""
395 AC_DEFINE_UNQUOTED(CMK_CONTEXT_FPU_POINTER, $pass, [whether ucontext has pointer])
396
397 if test $pass -eq 1
398 then
399 cat > $t <<EOT
400 #include <ucontext.h>
401
402 int main()
403 {
404   ucontext_t context;
405   context.uc_mcontext.uc_regs = 0;
406 }
407 EOT
408 test_cxx "whether ucontext uses uc_regs" "yes" "no" ""
409 AC_DEFINE_UNQUOTED(CMK_CONTEXT_FPU_POINTER_UCREGS, $pass, [whether ucontext uses uc_regs union])
410 fi
411
412 cat > $t <<EOT
413 #include <ucontext.h>
414 vrregset_t *v_regs;
415 ucontext_t  uc;
416
417 void foo()
418 {
419   vrregset_t *ptr = uc.uc_mcontext.v_regs;
420 }
421 EOT
422 test_cxx "whether ucontext has pointer (v_regs) of vector type" "yes" "no" ""
423 AC_DEFINE_UNQUOTED(CMK_CONTEXT_V_REGS, $pass, [whether ucontext has pointer (v_regs) of vector type])
424
425 ###################### C++ Compiler Features #####################
426
427 #### check C inline ####
428 cat > $tc <<EOT
429 inline static int foo()
430 {
431   return 1;
432 }
433 EOT
434 test_cc "whether inline works in C" "yes" "no" ""
435 AC_DEFINE_UNQUOTED(CMK_C_INLINE, $strictpass, [whether C inline works in C])
436
437 #### check explicit ####
438 cat > $t <<EOT
439 #include <stdlib.h>
440 class er {
441  protected:
442    explicit er(unsigned int inType) {};
443 };
444 EOT
445 test_cxx "whether C++ class explicit keyword works" "ok" "no" ""
446 AC_DEFINE_UNQUOTED(CMK_EXPLICIT, $pass, [whether C++ class explicit keyword works])
447
448 #### check if signed char is same as char ####
449 cat > $t <<EOT
450 #include <stdlib.h>
451 class er {
452  protected:
453    void operator()(char &v,const char *desc=NULL) {};
454    void operator()(signed char &v,const char *desc=NULL) {};
455 };
456 EOT
457 test_cxx "whether C++ signed char and char differ" "yes" "no" ""
458 AC_DEFINE_UNQUOTED(CMK_SIGNEDCHAR_DIFF_CHAR, $pass, [whether C++ signed char and char differ])
459
460 #### check if C++ casts work ####
461 cat > $t <<EOT
462 int foo(float *t) {return *reinterpret_cast<int *>(t);}
463 EOT
464 test_cxx "whether C++ *_casts<> work" "ok" "no" ""
465 AC_DEFINE_UNQUOTED(CMK_CPP_CAST_LEGAL, $pass, [C++ *_casts<> work])
466 AC_DEFINE_UNQUOTED(CMK_CPP_CAST_ILLEGAL, $fail, [C++ *_casts<> does not work])
467
468
469 ### check if varsize array on stack ####
470 cat > $t <<EOT
471 #include <stdio.h>
472 void foo()
473 {
474   int size=10;
475   char arr[size];
476 }
477
478 EOT
479 test_cxx "whether C++ allows declaration of varsize array" "yes" "no" ""
480 AC_DEFINE_UNQUOTED(CMK_DECLARE_VARSIZE_ARRAY, $pass, [whether C++ allows declaration of variable sized array])
481
482 ##### check if the stl headers use .h #####
483 cat > $t <<EOT
484 #include <iostream>
485 void foo(void) { std::cout<<"Hello, world"<<std::endl; }
486 EOT
487 test_cxx "whether including STL <foo> works" "ok" "no" ""
488 AC_DEFINE_UNQUOTED(CMK_STL_USE_DOT_H, $fail, [including STL <foo> does not works])
489 AC_DEFINE_UNQUOTED(CMK_STL_DONT_USE_DOT_H, $pass, [including STL <foo> works])
490
491 #### check if std::vector works ######
492 cat > $t <<EOT
493 #include <vector>
494
495 int foo(void) {
496   std::vector<int> v;      
497   v.push_back(2); v.push_back(3);
498   std::vector<int>::iterator it=v.begin();
499   it++;
500   return *it;
501 }
502 EOT
503 test_cxx "whether the std:: names for STL work" "ok" "no" ""
504 AC_DEFINE_UNQUOTED(CMK_USE_STL, $pass, [whether the std:: names for STL work])
505
506 #### check if namespaces can be defined #####
507 cat > $t <<EOT
508 namespace foo {
509         int x;
510 }
511 EOT
512 test_cxx "whether namespaces work" "ok" "no" ""
513 AC_DEFINE_UNQUOTED(CMK_NAMESPACES_BROKEN, $fail, [whether namespaces work])
514
515
516 #### check if typeinfo exists and works #####
517 cat > $t <<EOT
518 #include <typeinfo>
519 const char *foo(void) {
520         int x;
521         return typeid(x).name();
522 }
523 EOT
524 test_cxx "whether typeinfo/typeid works" "ok" "no" ""
525 AC_DEFINE_UNQUOTED(CMK_HAS_TYPEINFO, $pass, [whether typeinfo/typeid works])
526
527 #### check if iterator_traits is defined #####
528 cat > $t <<EOT
529 #include <iterator>
530
531 template <typename T> // T models Input Iterator
532 typename std::iterator_traits<T>::value_type accumulate(T first, T last)
533 {
534       typename std::iterator_traits<T>::value_type result = 0;
535       while(first != last)
536             result += *first++;
537       return result;
538 }
539 EOT
540 test_cxx "whether std::iterator_traits is defined" "ok" "no" ""
541 AC_DEFINE_UNQUOTED(CMK_HAS_ITERATOR_TRAITS, $pass, [whether iterator_traits works])
542
543 #### check if std::distance is defined #####
544 cat > $t <<EOT
545 #include <vector>
546 #include <iterator>
547
548 int foo()
549 {
550   std::vector<int> tree;
551   return std::distance(tree.begin(), tree.end());
552 }
553 EOT
554 test_cxx "whether std::distance is defined" "ok" "no" ""
555 AC_DEFINE_UNQUOTED(CMK_HAS_STD_DISTANCE, $pass, [whether std::distance works])
556
557
558 #### test if we can have multiple delete like this ####
559 cat > $t <<EOT
560 class foo {
561 public:
562   void operator delete(void*p){};
563   void operator delete(void*p,int*){};
564 };
565 EOT
566 test_cxx "whether operator delete can be overloaded in same class" "ok" "no" ""
567 AC_DEFINE_UNQUOTED(CMK_MULTIPLE_DELETE, $strictpass, [whether operator delete can be overloaded in same class])
568
569
570 #### test if we can use gcc x86 assembly like this ####
571 cat > $t <<EOT
572 double foo(void)
573 {
574   unsigned long long int v;
575   int *lo=0+(int *)&v;
576   int *hi=1+(int *)&v;
577   __asm__ __volatile__(
578       "rdtsc; movl %%edx,%0; movl %%eax,%1"
579       : /* output  */ "=m" (*hi), "=m" (*lo)
580       : /* input */
581       : /* trashes */ "%edx", "%eax"
582   );
583   return v;
584 }
585 EOT
586 test_cxx "whether GCC x86 assembly works" "yes" "no" ""
587 AC_DEFINE_UNQUOTED(CMK_GCC_X86_ASM, $strictpass, [Allows gcc x86 assembly.])
588
589 #### test if we can use gcc x86 assembly like this ####
590 if test $strictpass = 1
591 then
592 cat > $t <<EOT
593 int foo(void)
594 {
595   int x;
596   asm("lock incl %0" :: "m" (x));
597   asm("lock decl %0" :: "m" (x));
598   return x;
599 }
600 EOT
601 test_cxx "whether GCC x86 assembly for atomic increment works" "yes" "no" ""
602 AC_DEFINE_UNQUOTED(CMK_GCC_X86_ASM_ATOMICINCREMENT, $strictpass, [Allows gcc x86 assembly for atomic increment.])
603 fi
604
605 #### test if we can use gcc IA64 assembly like this ####
606 cat > $t <<EOT
607 double foo(void)
608 {
609         unsigned long long int x;
610         __asm__ __volatile__("mov %0=ar.itc" : "=r"(x) :: "memory");
611         return x;
612 }
613 EOT
614 test_cxx "whether GCC IA64 assembly works" "yes" "no" ""
615 AC_DEFINE_UNQUOTED(CMK_GCC_IA64_ASM, $strictpass, [Allows gcc IA64 assembly.])
616
617
618 #### test if we can use PPC assembly like this ####
619 cat > $t <<EOT
620 double foo(void)
621 {
622         unsigned long long int x;
623         asm volatile("eieio" ::: "memory");
624         return x;
625 }
626 EOT
627 test_cxx "whether PPC assembly works" "yes" "no" ""
628 AC_DEFINE_UNQUOTED(CMK_PPC_ASM, $strictpass, [Allows PPC assembly.])
629
630
631
632 #### test if we can use __thread ####
633 cat > $t <<EOT
634 __thread unsigned long long int x;
635 static __thread  int y;
636 void foo(void)
637 {
638         x = 1;
639         y = 1;
640 }
641 EOT
642 test_cxx "whether __thread (Thread Local Storage) is supported" "yes" "no" ""
643 AC_DEFINE_UNQUOTED(CMK_TLS_THREAD, $strictpass, [Allows __thread.])
644
645 #### test if we can build MPI ####
646 if test "$CMK_BUILD_MPI" = 1
647 then
648
649 cat > $t <<EOT
650 #include "mpi.h"
651 int main(int argc, char **argv)
652 {
653   MPI_Init(&argc, &argv);
654 }
655 EOT
656 mv -f ../include/mpi.h ../include/mpi.h.bak 2>/dev/null
657 test_cxx "whether build on MPI" "yes" "no" ""
658 AC_DEFINE_UNQUOTED(CMK_BUILD_ON_MPI, $strictpass, [build MPI.])
659 BUILD_MPI=$strictpass
660
661 if test $BUILD_MPI -eq 0
662 then
663   echo "Error: Can not compile a MPI program"
664   exit 1
665 fi
666
667 if test $BUILD_MPI -eq 1
668 then
669   test_link "whether need to specify MPI library" "no" "yes" ""
670   if test $pass -ne 1
671   then
672     if test -z "$CMK_MPI_LIB"
673     then
674       test_link "whether -lmpich" "ok" "no" "-lmpich"
675       if test $pass -eq 1
676       then
677         add_flag CMK_SYSLIBS='"$CMK_SYSLIBS -lmpich"' "mpi lib"
678       else
679         test_link "whether -lmpi" "ok" "no" "-lmpi"
680         if test $pass -eq 1
681         then
682                 add_flag CMK_SYSLIBS='"$CMK_SYSLIBS -lmpi"' "mpi lib"
683         else
684                 echo "Error: can not find mpi library"
685                 exit 1
686         fi
687       fi
688     else
689       add_flag CMK_SYSLIBS='"$CMK_SYSLIBS $CMK_MPI_LIB"' "mpi lib"
690     fi
691   fi
692 fi
693
694 if test $BUILD_MPI -eq 1
695 then
696 cat > $t <<EOT
697 #include "mpi.h"
698 int main(int argc, char **argv)
699 {
700   int thread_level, provided;
701   thread_level = MPI_THREAD_FUNNELED;
702   MPI_Init_thread(&argc, &argv, thread_level, &provided);
703 }
704 EOT
705 test_cxx "whether MPI_Init_thread is supported" "yes" "no" ""
706 AC_DEFINE_UNQUOTED(CMK_MPI_INIT_THREAD, $strictpass, [Allows MPI_Init_thread.])
707 fi
708 mv -f ../include/mpi.h.bak ../include/mpi.h 2>/dev/null
709
710 fi
711
712 ################### Syscalls and Libraries ###################
713
714 #### test for log2 ###
715 cat > $t <<EOT
716 #include <math.h>
717 int main() {
718   int i = log2(10);
719   return 0;
720 }
721 EOT
722 test_link "whether has log2" "yes" "no" ""
723 AC_DEFINE_UNQUOTED(CMK_HAS_LOG2, $pass, [whether has log2])
724
725 #### test for sqrtf ###
726 cat > $t <<EOT
727 #include <math.h>
728 int main() {
729   float i = sqrtf((float)10.0);
730   return 0;
731 }
732 EOT
733 test_link "whether has sqrtf" "yes" "no" ""
734 AC_DEFINE_UNQUOTED(CMK_HAS_SQRTF, $pass, [whether has sqrtf])
735
736 #### test for fabsf ###
737 cat > $t <<EOT
738 #include <math.h>
739 int main() {
740   float i = fabsf((float)10.0);
741   return 0;
742 }
743 EOT
744 test_link "whether has fabsf" "yes" "no" ""
745 AC_DEFINE_UNQUOTED(CMK_HAS_FABSF, $pass, [whether has fabsf])
746
747 #### test for mkstemp ###
748 cat > $t <<EOT
749 #include <stdlib.h>
750 #include <string.h>
751 int main() {
752   char fname[[128]];
753   strcpy(fname, "/tmp/fdXXX.XXX");
754   mkstemp(fname);
755   return 0;
756 }
757 EOT
758 test_link "whether has mkstemp" "yes" "no" ""
759 AC_DEFINE_UNQUOTED(CMK_USE_MKSTEMP, $pass, [whether has mkstemp])
760
761 #### test for system ###
762 cat > $t <<EOT
763 #include <stdlib.h>
764 int main() {
765   system("/bin/ls");
766   return 0;
767 }
768 EOT
769 test_link "whether has system" "yes" "no" ""
770 AC_DEFINE_UNQUOTED(CMK_HAS_SYSTEM, $pass, [whether has system])
771
772 #### test for sbrk ###
773 cat > $t <<EOT
774 #include <unistd.h>
775 int main() {
776   void *ptr  = sbrk(0); 
777 }
778 EOT
779 test_link "whether has sbrk" "yes" "no" ""
780 AC_DEFINE_UNQUOTED(CMK_HAS_SBRK, $pass, [whether has sbrk])
781
782 #### test for mstats ###
783 cat > $t <<EOT
784 #include <malloc.h>
785 int main() {
786   struct mstats ms = mstats();
787 }
788 EOT
789 test_link "whether has mstats" "yes" "no" ""
790 AC_DEFINE_UNQUOTED(CMK_HAS_MSTATS, $pass, [whether has mstats])
791
792 #### test for mallinfo ###
793 cat > $t <<EOT
794 #include <malloc.h>
795 int main() {
796   struct mallinfo mi = mallinfo();
797 }
798 EOT
799 test_link "whether has mallinfo" "yes" "no" ""
800 AC_DEFINE_UNQUOTED(CMK_HAS_MALLINFO, $pass, [whether has mallinfo])
801
802 #### test for popen ###
803 cat > $t <<EOT
804 #include <stdio.h>
805 int main() {
806   FILE *p = popen("/bin/ps", "r");
807   pclose(p);
808 }
809 EOT
810 test_link "whether has popen" "yes" "no" ""
811 AC_DEFINE_UNQUOTED(CMK_HAS_POPEN, $pass, [whether has popen])
812
813 #### test for poll ###
814 cat > $t <<EOT
815 #include <poll.h>
816 void foo(void) { 
817   struct pollfd pos[[3]];
818   poll(pos, 1, 1);
819 }
820 EOT
821 test_cxx "whether poll() syscall exists" "yes" "no" ""
822 AC_DEFINE_UNQUOTED(CMK_USE_POLL, $pass, [whether the poll() syscall exists])
823
824 #### check if getpid exists ####
825 cat > $tc <<EOT
826 #include <sys/types.h>
827 #include <unistd.h>
828
829 int main(int argc, char **argv) {
830     pid_t pid = getpid();
831 }
832 EOT
833 test_linkc "whether getpid() exists" "yes" "no" ""
834 AC_DEFINE_UNQUOTED(CMK_HAS_GETPID, $pass, [whether getpid() exists])
835
836 #### check if kill exists ####
837 cat > $tc <<EOT
838 #include <sys/types.h>
839 #include <unistd.h>
840 #include <signal.h>
841
842 int main(int argc, char**argv) 
843 {
844     pid_t pid = getpid();
845     kill(pid, 9);
846 }
847 EOT
848 test_linkc "whether kill() exists" "yes" "no" ""
849 AC_DEFINE_UNQUOTED(CMK_HAS_KILL, $pass, [whether kill() exists])
850
851 #### test for setpriority ###
852 cat > $t <<EOT
853 #include <sys/time.h>
854 #include <sys/resource.h>
855 void foo(void) { 
856   setpriority(PRIO_PROCESS, 0, 0);
857 }
858 EOT
859 test_cxx "whether setpriority() exists" "yes" "no" ""
860 AC_DEFINE_UNQUOTED(CMK_HAS_SETPRIORITY, $pass, [whether the setpriority() exists])
861
862 #### test for system ###
863 cat > $t <<EOT
864 #include "ckdll_system.C"
865 EOT
866 test_cxx "whether to use signal-safe system() " "yes" "no" ""
867 AC_DEFINE_UNQUOTED(CMK_SIGSAFE_SYSTEM, $pass, [whether to use signal-safe system()])
868
869 ### test sched_setaffinity ####
870 cat > $tc <<EOT
871 #include <stdlib.h>
872 #include <stdio.h>
873 #include <unistd.h>
874
875 #define _GNU_SOURCE
876 #include <sched.h>
877 long sched_setaffinity(pid_t pid, unsigned int len, unsigned long *user_mask_ptr);
878 long sched_getaffinity(pid_t pid, unsigned int len, unsigned long *user_mask_ptr);
879
880 int main()
881 {
882   unsigned long mask = 0xffffffff;
883   unsigned int len = sizeof(mask);
884
885   if (sched_setaffinity(0, len, &mask) < 0) {
886     return -1;
887   }
888   return 0;
889 }
890 EOT
891 test_linkc "whether sched_setaffinity call exists" "yes" "no" ""
892 AC_DEFINE_UNQUOTED(CMK_HAS_SETAFFINITY, $pass, [whether the sched_setaffinity() exists])
893
894 ### test pthread_setaffinity_np ####
895 cat > $tc <<EOT
896 #include <stdlib.h>
897 #include <stdio.h>
898 #include <unistd.h>
899 #include <pthread.h>
900
901 int main()
902 {
903   unsigned long mask = 0xffffffff;
904   unsigned int len = sizeof(mask);
905
906   if (pthread_setaffinity_np(pthread_self(), len, &mask) < 0) {
907     return -1;
908   }
909   return 0;
910 }
911 EOT
912 test_linkc "whether pthread_setaffinity_np call exists" "yes" "no" "-lpthread"
913 AC_DEFINE_UNQUOTED(CMK_HAS_PTHREAD_SETAFFINITY, $pass, [whether the pthread_setaffinity_np() exists])
914
915 #### check bindprocessors on AIX ####
916 cat > $tc <<EOT
917 #include <stdlib.h>
918 #include <stdio.h>
919 #include <unistd.h>
920
921 #include <sys/processor.h>
922
923 int main()
924 {
925   int retValue = 0;
926   int pid;
927   pid = getpid();
928   if (bindprocessor(BINDPROCESS, pid, 0) == -1) return -1;
929   return 0;
930 }
931 EOT
932 test_linkc "whether bindprocessor call exists" "yes" "no" ""
933 AC_DEFINE_UNQUOTED(CMK_HAS_BINDPROCESSOR, $pass, [whether the bindprocessor()
934 exists])
935
936
937 #### check if dlopen works ####
938 skip_dl=0
939 # for bproc, ignore -ldl
940 test -n "$CMK_BPROC" && skip_dl=1
941 test -n "$CMK_NO_DL" && skip_dl=1
942 dl_opt='-ldl'
943 #workaround for pgcc 4.0, -ldl crash linking, so use -Wl,-ldl to skip the prelinker.
944 case "$CMK_CXX" in
945 pgCC*) dl_opt='-Wl,-ldl' ;;
946 esac
947
948 if test $skip_dl -eq 0 
949 then
950
951 cat > $t <<EOT
952 #include "ckdll_dlopen.C"
953 int main() {
954         CkDll dll("foo.so");
955         return 0;
956 }
957 EOT
958 test_link "whether dlopen links without $dl_opt" "yes" "no" ""
959 noldl=$pass
960 test_link "whether dlopen links with $dl_opt" "yes" "no" "$dl_opt"
961 if test $pass -eq 1
962 then 
963 #dlopen requires -ldl: add it to our link line
964         add_flag CMK_LIBS='"$CMK_LIBS '$dl_opt'"' "dlopen"
965 fi
966
967 if test $pass -eq 1 -o $noldl -eq 1
968 then
969 # One version or another of dlopen worked: compile it in
970         AC_DEFINE_UNQUOTED(CMK_DLL_USE_DLOPEN, 1, [dlopen])
971 fi
972
973 ### test gethostname ####
974 cat > $tc <<EOT
975 #ifdef WIN32
976 #include <Winsock2.h>
977 #else
978 #include <stdlib.h>
979 #include <stdio.h>
980 #include <unistd.h>
981 #endif
982
983 int main()
984 {
985   char hostname[[1000]];
986   gethostname(hostname, 999);
987   return 0;
988 }
989 EOT
990 test_linkc "whether gethostname call exists" "yes" "no" ""
991 AC_DEFINE_UNQUOTED(CMK_HAS_GETHOSTNAME, $pass, [whether gethostname() exists])
992
993 #### check if getProcAddress works ####
994 cat > $t <<EOT
995 #include "ckdll_win32.C"
996 EOT
997 test_cxx "whether getProcAddress works" "yes" "no" ""
998 AC_DEFINE_UNQUOTED(CMK_DLL_USE_WIN32, $pass, [whether getProcAddress works])
999
1000 fi    # end of skip_dl
1001
1002 #### check if socklen_t exists ####
1003 cat > $t <<EOT
1004 #include <sys/types.h>
1005 #include <sys/socket.h>
1006
1007 void foo(void) {
1008         int i;
1009         socklen_t s=sizeof(i);
1010 }
1011 EOT
1012 test_cxx "whether has socklen_t" "yes" "no" ""
1013 AC_DEFINE_UNQUOTED(CMK_HAS_SOCKLEN, $pass, [whether has socklen_t])
1014
1015 #### check if mmap exists ####
1016 cat > $t <<EOT
1017 #include <sys/types.h>
1018 #include <sys/mman.h>
1019
1020 void *foo(void *a,int l,int fd) {
1021         return mmap((caddr_t)a,l,PROT_READ+PROT_WRITE,
1022                  MAP_FIXED+MAP_PRIVATE,fd,0);
1023 }
1024 EOT
1025 test_cxx "whether the mmap() syscall exists" "yes" "no" ""
1026 AC_DEFINE_UNQUOTED(CMK_HAS_MMAP, $pass, [whether the mmap() syscall exists])
1027
1028 #### check if mmap accepts MAP_ANON ####
1029 cat > $t <<EOT
1030 #include <sys/types.h>
1031 #include <sys/mman.h>
1032
1033 void *foo(void *a,int l) {
1034         return mmap((caddr_t)a,l,PROT_READ+PROT_WRITE,
1035                 MAP_FIXED+MAP_PRIVATE+MAP_ANON,-1,0);
1036 }
1037 EOT
1038 test_cxx "whether mmap() accepts MAP_ANON" "yes" "no" ""
1039 AC_DEFINE_UNQUOTED(CMK_HAS_MMAP_ANON, $pass, [whether mmap() accepts MAP_ANON])
1040
1041 #### check if mmap accepts MAP_NORESERVE ####
1042 cat > $t <<EOT
1043 #include <sys/types.h>
1044 #include <sys/mman.h>
1045
1046 void *foo(void *a,int l) {
1047         return mmap((caddr_t)a,l,PROT_READ+PROT_WRITE,
1048                 MAP_FIXED+MAP_PRIVATE+MAP_NORESERVE,-1,0);
1049 }
1050 EOT
1051 test_cxx "whether mmap() accepts MAP_NORESERVE" "yes" "no" ""
1052 AC_DEFINE_UNQUOTED(CMK_HAS_MMAP_NORESERVE, $pass, [whether mmap() accepts MAP_NORESERVE])
1053
1054 #### check if get_myaddress exists ####
1055 cat > $t <<EOT
1056 #include <rpc/rpc.h>
1057
1058 void foo(void *a) {
1059     get_myaddress((struct sockaddr_in*)a);
1060 }
1061 EOT
1062 test_cxx "whether get_myaddress() exists" "yes" "no" ""
1063 AC_DEFINE_UNQUOTED(CMK_HAS_GET_MYADDRESS, $pass, [whether get_myaddress() exists])
1064
1065 #### check if glibc backtrace exists ####
1066 cat > $t <<EOT
1067 #include "cmibacktrace.c"
1068
1069 int main() {
1070         int nLevels=1;
1071         void *stack;
1072         CmiBacktraceRecord(&stack,0,&nLevels);
1073         return 0;
1074 }
1075 EOT
1076 TRACE_LINK_FLAG="-rdynamic"
1077 test_link "whether glibc backtrace works" "yes" "no" "-DCMK_USE_BACKTRACE=1 $TRACE_LINK_FLAG"
1078 AC_DEFINE_UNQUOTED(CMK_USE_BACKTRACE, $pass, [whether glibc backtrace works])
1079
1080 if test $strictpass -eq 1
1081 then 
1082         add_flag 'CMK_LD="$CMK_LD '$TRACE_LINK_FLAG'"' "backtrace"
1083         add_flag 'CMK_LDXX="$CMK_LDXX '$TRACE_LINK_FLAG'"' "backtrace"
1084 fi
1085
1086 #### test sleep ####
1087 cat > $t <<EOT
1088 #include <unistd.h>
1089 int main() {
1090   sleep(1);
1091   return 0;
1092 }
1093 EOT
1094 test_cxx "whether has sleep " "yes" "no" ""
1095 AC_DEFINE_UNQUOTED(CMK_HAS_SLEEP, $pass, [whether has sleep])
1096
1097 #### test usleep ####
1098 cat > $t <<EOT
1099 #include <unistd.h>
1100 int main() {
1101   usleep(100);
1102   return 0;
1103 }
1104 EOT
1105 test_cxx "whether has usleep " "yes" "no" ""
1106 AC_DEFINE_UNQUOTED(CMK_HAS_USLEEP, $pass, [whether has usleep])
1107
1108 #### test personality() and ADDR_NO_RANDOMIZE ####
1109 # Only works on modern Linux systems
1110 cat > $t <<EOT
1111 #include <sys/personality.h>
1112 int main() {
1113     int orig_persona = personality(0xffffffff);
1114     personality(orig_persona | ADDR_NO_RANDOMIZE);
1115     return 0;
1116 }
1117 EOT
1118 test_cxx "whether personality() and ADDR_NO_RANDOMIZE exist" "yes" "no" ""
1119 AC_DEFINE_UNQUOTED(CMK_HAS_ADDR_NO_RANDOMIZE, $pass, [whether personality() and ADDR_NO_RANDOMIZE exist])
1120
1121
1122 #### test if has zlib ####
1123 # bproc doesnot like -lz in any case
1124 if test -z "$CMK_BPROC"
1125 then
1126
1127 cat > $t <<EOT
1128 #include <zlib.h>
1129 int main() { 
1130   gzFile f = gzopen("/tmp/x","r");
1131   gzprintf(f, "test...\n");
1132   gzclose(f);
1133   return 0;
1134 }
1135 EOT
1136 test_link "whether has zlib" "yes" "no" "-lz"
1137 AC_DEFINE_UNQUOTED(CMK_PROJECTIONS_USE_ZLIB, $pass, [whether has zlib])
1138 if test $pass -eq 1
1139 then 
1140         add_flag 'CMK_LIBZ="-lz"' "zlib"
1141 fi
1142
1143 fi
1144
1145 #### test if has elf.h ####
1146 cat > $t <<EOT
1147 #include <elf.h>
1148 typedef Elf32_Addr ELF_TYPE_Addr;
1149 int main() { 
1150 }
1151 EOT
1152 test_cxx "whether has elf.h " "yes" "no" ""
1153 AC_DEFINE_UNQUOTED([CMK_HAS_ELF_H], $pass, [whether has elf.h])
1154
1155 #### test if has Multiprocessing.h for apple ####
1156 cat > $t <<EOT
1157 #include <Carbon/Carbon.h>
1158 #include <Multiprocessing.h>
1159 int main() {
1160   int a = MPProcessorsScheduled();
1161 }
1162 EOT
1163 test_cxx "whether has Multiprocessing.h for Apple " "yes" "no" ""
1164 AC_DEFINE_UNQUOTED([CMK_HAS_MULTIPROCESSING_H], $pass, [whether has Multiprocessing.h])
1165
1166 #### test if "ntohl" is available ####
1167 cat > $t <<EOT
1168 #if defined(_WIN32) && ! defined(__CYGWIN__) || defined(__MINGW_H)
1169 #include <winsock.h>
1170 #else
1171 #include <netinet/in.h>
1172 #include <arpa/inet.h>
1173 #endif
1174
1175 int main() {
1176   int i = 100;
1177   i = ntohl(i);
1178   return 0;
1179 }
1180 EOT
1181 test_link "whether ntohl is available" "yes" "no" ""
1182 AC_DEFINE_UNQUOTED(CMK_HAS_NTOHL, $pass, [whether ntohl is available])
1183
1184 ### test for libjpeg ####
1185 cat > $t <<EOT
1186 #include <stdio.h>
1187 #include <stdlib.h>
1188 #include "jpeglib.h"
1189
1190 int main()
1191 {
1192   struct jpeg_compress_struct cinfo;
1193   jpeg_create_compress(&cinfo);
1194   return 0;
1195 }
1196 EOT
1197 test_link "whether has libjpeg" "yes" "no" "-ljpeg"
1198 AC_DEFINE_UNQUOTED(CMK_USE_LIBJPEG, $pass, [whether has libjpeg])
1199 if test $pass -eq 1
1200 then
1201         add_flag 'CMK_LIBJPEG="-ljpeg"' "libjpeg"
1202 fi
1203
1204 #### check if PAPI exists ####
1205 if test -n "$CMK_USE_PAPI"
1206 then
1207 cat > $t <<EOT
1208 #include <stdio.h>
1209 #include <papi.h>
1210                                                                                 
1211 int main() {
1212     int Events[[1]] = { PAPI_TOT_CYC };
1213     if (PAPI_start_counters(Events, 1) != PAPI_OK) return 1;
1214     return 0;
1215 }
1216 EOT
1217 test_link "whether PAPI exists" "yes" "no" "-lpapi"
1218 AC_DEFINE_UNQUOTED(CMK_HAS_COUNTER_PAPI, $pass, [whether PAPI exists])
1219 if test $pass -eq 1
1220 then 
1221         add_flag 'CMK_LIBS="$CMK_LIBS -lpapi"' "papi"
1222 fi
1223 fi
1224
1225 #### test if Python headers are installed ####
1226 PYTHON_VERSION=`python -V 2>&1 | awk {'print $2'} | awk -F. {'print $1"."$2'}`
1227 cat > $t <<EOT
1228 #include "python${PYTHON_VERSION}/Python.h"
1229 #include "python${PYTHON_VERSION}/compile.h"
1230 #include "python${PYTHON_VERSION}/eval.h"
1231 #include "python${PYTHON_VERSION}/node.h"
1232
1233 int main() {
1234     Py_Initialize();
1235     PyEval_InitThreads();
1236     struct _node* programNode = PyParser_SimpleParseString("return 1\n",Py_file_input);
1237     PyCodeObject *program = PyNode_Compile(programNode, "");
1238 }
1239 EOT
1240 test_link "whether Python is installed" "yes" "no" "-lpython$PYTHON_VERSION -lpthread -lutil -ldl"
1241 AC_DEFINE_UNQUOTED(CMK_HAS_PYTHON, $pass, [whether Python is installed])
1242 AC_DEFINE_UNQUOTED(CMK_PYTHON_VERSION, ${PYTHON_VERSION}, [Python version])
1243 if test $pass -eq 1
1244 then
1245         add_flag "CMK_BUILD_PYTHON=$PYTHON_VERSION" "python"
1246 fi
1247
1248 #### test if it can build shared library ####
1249 cat > $t <<EOT
1250 #include "stdlib.h"
1251 extern int foo();
1252 int foo1() { 
1253   void * t= malloc(2);
1254   foo();
1255   return 0;
1256 }
1257 EOT
1258 test_linkso "whether can build shared library" "yes" "no" ""
1259 if test $pass -eq 0
1260 then 
1261         add_flag 'CMK_NO_BUILD_SHARED="true"' "build-shared"
1262 else
1263         BUILD_SHARED=1
1264         if test $BUILD_MPI -eq 1
1265         then
1266 cat > $t <<EOT
1267 #include "stdlib.h"
1268 #include "mpi.h"
1269 extern int foo();
1270 int foo(int argc, char ** argv) {
1271   void * t= malloc(2);
1272   foo();
1273   MPI_Init(&argc, &argv);
1274   return 0;
1275 }
1276 EOT
1277                 test_linkso "whether can build shared library with MPI" "yes" "no" ""
1278                 BUILD_SHARED=$pass
1279         fi
1280         if test $BUILD_SHARED -eq 1
1281         then
1282                 add_flag 'CMK_NO_BUILD_SHARED="false"' "build-shared"
1283         else
1284                 add_flag 'CMK_NO_BUILD_SHARED="true"' "build-shared"
1285         fi
1286 fi
1287
1288 #### test the version number of bproc ####
1289 if test -n "$CMK_BPROC"
1290 then
1291 cat > $t <<EOT
1292 #include <stdio.h>
1293 #include <sys/bproc.h>
1294 int main()
1295 {
1296   struct bproc_version_t vers;
1297   bproc_version(&vers);
1298   printf("%s\n", vers.version_string);
1299 }
1300 EOT
1301 test_link "whether bproc compiles" "yes" "no" "-lbproc"
1302 if test $pass -eq 1
1303 then 
1304 AC_MSG_CHECKING("bproc version")
1305 bproc_ver=`./testlink`
1306 if test x$bproc_ver = x
1307 then
1308 test_result 0 "bproc version" "ERROR" ""
1309 test_finish 1
1310 else
1311 test_result 0 "bproc version" "$bproc_ver" ""
1312 fi
1313 bproc_ver=`echo $bproc_ver | cut -d'.' -f1`
1314 AC_DEFINE_UNQUOTED(CMK_BPROC_VERSION, $bproc_ver, [bproc version])
1315 fi
1316 fi
1317
1318 #### test the if command sync exists ####
1319 AC_CHECK_PROG(SYNC, sync, sync )
1320 if test -n "$SYNC"
1321 then
1322 AC_DEFINE_UNQUOTED(CMK_HAS_SYNC, 1, [sync program])
1323 fi
1324
1325 ################## Fortran #########################
1326
1327 #echo "set F77 compiler as: $CMK_CF77"
1328 AC_MSG_CHECKING("F77 compiler as")
1329 AC_MSG_RESULT("$CMK_CF77")
1330
1331 AC_MSG_CHECKING("whether Fortran 77 compiler works")
1332 ### test fortran 77 compiler ###
1333 cat > conftest.f <<EOF
1334       SUBROUTINE FOO_foo
1335       END
1336 EOF
1337 $CMK_CF77 -c conftest.f > /dev/null 2> /dev/null
1338 if test ! -r conftest.o
1339 then
1340   AC_MSG_RESULT("no")
1341 else
1342   AC_MSG_RESULT("yes")
1343 fi
1344
1345 ### test fortran 90 compiler ###
1346 #echo "set F90 compiler as: $CMK_CF90"
1347 AC_MSG_CHECKING("F90 compiler as")
1348 AC_MSG_RESULT("$CMK_CF90")
1349
1350 AC_MSG_CHECKING("whether Fortran 90 compiler works")
1351 cat > conftest2.f90 <<EOF
1352       SUBROUTINE FOO_foo
1353       END
1354 EOF
1355 $CMK_CF90 -c conftest2.f90 > /dev/null 2> /dev/null
1356 if test ! -r conftest2.o
1357 then
1358   AC_MSG_RESULT("no")
1359 else
1360   AC_MSG_RESULT("yes")
1361   mv -f conftest2.o conftest.o
1362   USE_FORTRAN90=1
1363 fi
1364
1365 ### check fortran name mangling
1366 AC_MSG_CHECKING(subroutine name used by Fortran 90 compiler)
1367
1368 if test -r conftest.o
1369 then
1370   AC_CACHE_VAL(fortran_postfix,
1371
1372   NAME=`$CMK_NM conftest.o | grep "foo_foo__"`
1373   if test "$NAME" != ""
1374   then
1375     fortran_postfix=TWOSCORE
1376     AC_DEFINE_UNQUOTED(CMK_FORTRAN_USES_TWOSCORE, 1, [TWOSCORE])
1377   else
1378     NAME=`$CMK_NM conftest.o | grep "foo_foo_"`
1379     if test "$NAME" != ""
1380     then
1381       fortran_postfix=ONESCORE
1382       AC_DEFINE_UNQUOTED(CMK_FORTRAN_USES_ONESCORE, 1, [ONESCORE])
1383     else
1384       NAME=`$CMK_NM conftest.o | grep "foo_foo"`
1385       if test "$NAME" != ""
1386       then
1387         fortran_postfix=NOSCORE
1388         AC_DEFINE_UNQUOTED(CMK_FORTRAN_USES_NOSCORE, 1, [NOSCORE])
1389       else
1390         NAME=`$CMK_NM conftest.o | grep "FOO_FOO"`
1391         if test "$NAME" != ""
1392         then
1393           fortran_postfix=ALLCAPS
1394           AC_DEFINE_UNQUOTED(CMK_FORTRAN_USES_ALLCAPS, 1, [ALLCAPS])
1395         else
1396           echo "#################################################"
1397           echo "FORTRAN compiler generated name not supported yet"
1398           echo "#################################################"
1399         fi
1400       fi
1401     fi
1402   fi
1403   rm -f conftest.f conftest.o
1404   )
1405   AC_MSG_RESULT($fortran_postfix)
1406 else
1407   AC_MSG_RESULT("Fortran compiler not working")
1408 fi
1409
1410 ### check module name ###
1411
1412 if test "$USE_FORTRAN90" = 1
1413 then
1414   cat > conftest.f90 <<EOF
1415       MODULE testmod
1416         interface 
1417           function fpup_issizing(p)
1418           INTEGER :: p
1419           logical fpup_issizing
1420           end function
1421         end interface
1422       END MODULE
1423 EOF
1424   AC_MSG_CHECKING(Fortran 90 mod name is capital)
1425   $CMK_CF90 -c conftest.f90 > /dev/null 2> /dev/null
1426   name=`ls TESTMOD.* 2>/dev/null`
1427   if test -n "$name"
1428   then
1429         AC_MSG_RESULT("yes")
1430         add_flag 'CMK_MOD_NAME_ALLCAPS=1' "mod name capital"
1431   else
1432         AC_MSG_RESULT("no")
1433         name=`ls testmod.* 2>/dev/null`
1434   fi
1435   if test -n "$name"
1436   then
1437         AC_MSG_CHECKING(Fortran 90 mod name extension)
1438         ext=`echo $name | sed -e 's/^[[^.]]*\.//'`
1439         add_flag 'CMK_MOD_EXT="'$ext'"' "mod name extension"
1440         AC_MSG_RESULT("$ext")
1441         /bin/rm -f $name
1442   fi
1443   /bin/rm -f conftest.f90
1444 fi
1445
1446 ### Check that Linux's C library is recent enough to provide working pthreads
1447 if test "$base_version" = "net-linux" || test "$base_version" = "mpi-linux"
1448 then
1449 case $version in *linux*smp*|*linux*vmi*)
1450     AC_MSG_CHECKING(glibc version)
1451     get_glibc_version
1452     AC_MSG_RESULT($GLIBCVERSION)
1453     if test 0 = `expr $GLIBCVERSION \> 2.2.92`
1454     then
1455        echo "Your version of GLIBC is ancient, and does not have sufficient "
1456        echo "support for pthreads."
1457        exit 1
1458     fi
1459 esac
1460 fi
1461
1462 AC_OUTPUT(
1463 libs/ck-libs/ampi/ampiCC libs/ck-libs/ampi/ampirun,
1464
1465 chmod +x libs/ck-libs/ampi/ampiCC libs/ck-libs/ampi/ampirun
1466 )