armci-mpi/ 0000755 0001750 0001750 00000000000 12663426407 012216 5 ustar mbanck mbanck armci-mpi/VERSION 0000644 0001750 0001750 00000001155 12663426407 013270 0 ustar mbanck mbanck # For libtool ABI versioning rules see:
# http://www.nondot.org/sabre/Mirrored/libtool-2.1a/libtool_6.html#SEC36
# 1. If the library source code has changed at all since the last
# update, then increment revision (`c:r:a' becomes `c:r+1:a').
#
# 2. If any interfaces have been added, removed, or changed since
# the last update, increment current, and set revision to 0.
#
# 3. If any interfaces have been added since the last public
# release, then increment age.
#
# 4. If any interfaces have been removed since the last public
# release, then set age to 0.
libarmci_abi_version=1:0:0
armci-mpi/travis/ 0000755 0001750 0001750 00000000000 12663426407 013526 5 ustar mbanck mbanck armci-mpi/travis/install-mpi.sh 0000755 0001750 0001750 00000006010 12663426407 016313 0 ustar mbanck mbanck #!/bin/sh
# This configuration file was taken originally from the mpi4py project
# , and then modified for Julia
set -e
set -x
os=`uname`
TRAVIS_ROOT="$1"
MPI_IMPL="$2"
# this is where updated Autotools will be for Linux
export PATH=$TRAVIS_ROOT/bin:$PATH
case "$os" in
Darwin)
echo "Mac"
brew update
case "$MPI_IMPL" in
mpich)
brew install mpich
;;
openmpi)
# Homebrew is still at 1.10.1, which is broken for STRIDED/IOV=DIRECT.
brew install openmpi
;;
*)
echo "Unknown MPI implementation: $MPI_IMPL"
exit 10
;;
esac
;;
Linux)
echo "Linux"
case "$MPI_IMPL" in
mpich)
if [ ! -d "$TRAVIS_ROOT/mpich" ]; then
wget -q --no-check-certificate http://www.mpich.org/static/downloads/3.2/mpich-3.2.tar.gz
tar -xzf mpich-3.2.tar.gz
cd mpich-3.2
mkdir build && cd build
../configure CFLAGS="-w" --prefix=$TRAVIS_ROOT/mpich --disable-fortran --disable-static
make -j4
make install
else
echo "MPICH already installed"
fi
;;
openmpi)
if [ ! -d "$TRAVIS_ROOT/open-mpi" ]; then
wget -q --no-check-certificate http://www.open-mpi.org/software/ompi/v1.10/downloads/openmpi-1.10.2rc3.tar.bz2
tar -xjf openmpi-1.10.2rc3.tar.bz2
cd openmpi-1.10.2rc3
mkdir build && cd build
../configure CFLAGS="-w" --prefix=$TRAVIS_ROOT/open-mpi \
--without-verbs --without-fca --without-mxm --without-ucx \
--without-portals4 --without-psm --without-psm2 \
--without-libfabric --without-usnic \
--without-udreg --without-ugni --without-xpmem \
--without-alps --without-munge \
--without-sge --without-loadleveler --without-tm \
--without-lsf --without-slurm \
--without-pvfs2 --without-plfs \
--without-cuda --disable-oshmem \
--disable-mpi-fortran --disable-oshmem-fortran \
--disable-libompitrace \
--disable-mpi-io --disable-io-romio \
--disable-static
make -j4
make install
else
echo "Open-MPI already installed"
fi
;;
*)
echo "Unknown MPI implementation: $MPI_IMPL"
exit 20
;;
esac
;;
esac
armci-mpi/travis/install-autotools.sh 0000755 0001750 0001750 00000007432 12663426407 017570 0 ustar mbanck mbanck #!/bin/sh
set -e
set -x
os=`uname`
TOP="$1"
case "$os" in
Darwin)
brew update
brew info autoconf automake libtool
#brew install autoconf automake libtool
brew upgrade autoconf automake libtool
which glibtool
which glibtoolize
glibtool --version
mkdir -p ${TOP}/bin
ln -s `which glibtool` ${TOP}/bin/libtool
ln -s `which glibtoolize` ${TOP}/bin/libtoolize
;;
Linux)
MAKE_JNUM=2
M4_VERSION=1.4.17
LIBTOOL_VERSION=2.4.4
AUTOCONF_VERSION=2.69
AUTOMAKE_VERSION=1.15
cd ${TOP}
TOOL=m4
TDIR=${TOOL}-${M4_VERSION}
FILE=${TDIR}.tar.gz
BIN=${TOP}/bin/${TOOL}
if [ -f ${FILE} ] ; then
echo ${FILE} already exists! Using existing copy.
else
wget http://ftp.gnu.org/gnu/${TOOL}/${FILE}
fi
if [ -d ${TDIR} ] ; then
echo ${TDIR} already exists! Using existing copy.
else
echo Unpacking ${FILE}
tar -xzf ${FILE}
fi
if [ -f ${BIN} ] ; then
echo ${BIN} already exists! Skipping build.
else
cd ${TOP}/${TDIR}
./configure --prefix=${TOP} && make -j ${MAKE_JNUM} && make install
if [ "x$?" != "x0" ] ; then
echo FAILURE 1
exit
fi
fi
cd ${TOP}
TOOL=libtool
TDIR=${TOOL}-${LIBTOOL_VERSION}
FILE=${TDIR}.tar.gz
BIN=${TOP}/bin/${TOOL}
if [ ! -f ${FILE} ] ; then
wget http://ftp.gnu.org/gnu/${TOOL}/${FILE}
else
echo ${FILE} already exists! Using existing copy.
fi
if [ ! -d ${TDIR} ] ; then
echo Unpacking ${FILE}
tar -xzf ${FILE}
else
echo ${TDIR} already exists! Using existing copy.
fi
if [ -f ${BIN} ] ; then
echo ${BIN} already exists! Skipping build.
else
cd ${TOP}/${TDIR}
./configure --prefix=${TOP} M4=${TOP}/bin/m4 && make -j ${MAKE_JNUM} && make install
if [ "x$?" != "x0" ] ; then
echo FAILURE 2
exit
fi
fi
cd ${TOP}
TOOL=autoconf
TDIR=${TOOL}-${AUTOCONF_VERSION}
FILE=${TDIR}.tar.gz
BIN=${TOP}/bin/${TOOL}
if [ ! -f ${FILE} ] ; then
wget http://ftp.gnu.org/gnu/${TOOL}/${FILE}
else
echo ${FILE} already exists! Using existing copy.
fi
if [ ! -d ${TDIR} ] ; then
echo Unpacking ${FILE}
tar -xzf ${FILE}
else
echo ${TDIR} already exists! Using existing copy.
fi
if [ -f ${BIN} ] ; then
echo ${BIN} already exists! Skipping build.
else
cd ${TOP}/${TDIR}
./configure --prefix=${TOP} M4=${TOP}/bin/m4 && make -j ${MAKE_JNUM} && make install
if [ "x$?" != "x0" ] ; then
echo FAILURE 3
exit
fi
fi
cd ${TOP}
TOOL=automake
TDIR=${TOOL}-${AUTOMAKE_VERSION}
FILE=${TDIR}.tar.gz
BIN=${TOP}/bin/${TOOL}
if [ ! -f ${FILE} ] ; then
wget http://ftp.gnu.org/gnu/${TOOL}/${FILE}
else
echo ${FILE} already exists! Using existing copy.
fi
if [ ! -d ${TDIR} ] ; then
echo Unpacking ${FILE}
tar -xzf ${FILE}
else
echo ${TDIR} already exists! Using existing copy.
fi
if [ -f ${BIN} ] ; then
echo ${BIN} already exists! Skipping build.
else
cd ${TOP}/${TDIR}
./configure --prefix=${TOP} M4=${TOP}/bin/m4 && make -j ${MAKE_JNUM} && make install
if [ "x$?" != "x0" ] ; then
echo FAILURE 4
exit
fi
fi
;;
esac
armci-mpi/travis/build-run.sh 0000755 0001750 0001750 00000001327 12663426407 015771 0 ustar mbanck mbanck #! /bin/sh
# Exit on error
set -ev
os=`uname`
TRAVIS_ROOT="$1"
MPI_IMPL="$2"
# Environment variables
export CFLAGS="-std=c99"
#export MPICH_CC=$CC
export MPICC=mpicc
case "$os" in
Darwin)
;;
Linux)
export PATH=$TRAVIS_ROOT/mpich/bin:$PATH
export PATH=$TRAVIS_ROOT/open-mpi/bin:$PATH
;;
esac
# Capture details of build
case "$MPI_IMPL" in
mpich)
mpichversion
mpicc -show
;;
openmpi)
# this is missing with Mac build it seems
#ompi_info --arch --config
mpicc --showme:command
;;
esac
# Configure and build
./autogen.sh
./configure --disable-static --enable-win-allocate
# Run unit tests
export ARMCI_VERBOSE=1
make check
armci-mpi/benchmarks/ 0000755 0001750 0001750 00000000000 12662706250 014327 5 ustar mbanck mbanck armci-mpi/benchmarks/bench_groups.c 0000644 0001750 0001750 00000004034 12662706250 017152 0 ustar mbanck mbanck /*
* Copyright (C) 2010. See COPYRIGHT in top-level directory.
*/
#include
#include
#include
#include
#define PART_SIZE 1
int main(int argc, char **argv) {
int me, nproc;
int i, *procs;
ARMCI_Group g_world, g_odd, g_even;
MPI_Init(&argc, &argv);
ARMCI_Init();
MPI_Comm_rank(MPI_COMM_WORLD, &me);
MPI_Comm_size(MPI_COMM_WORLD, &nproc);
procs = malloc(sizeof(int) * ( nproc/2 + (nproc % 2 ? 1 : 0 )));
if (me == 0) printf("ARMCI Group test starting on %d procs\n", nproc);
ARMCI_Group_get_world(&g_world);
if (me == 0) printf(" + Creating odd group\n");
for (i = 1; i < nproc; i += 2) {
procs[i/2] = i;
}
ARMCI_Group_create_child(i/2, procs, &g_odd, &g_world);
if (me == 0) printf(" + Creating even group\n");
for (i = 0; i < nproc; i += 2) {
procs[i/2] = i;
}
ARMCI_Group_create_child(i/2, procs, &g_even, &g_world);
/***********************************************************************/
{
int grp_me, grp_nproc;
double t_abs_to_grp, t_grp_to_abs;
const int iter = 1000000;
if (me == 0) {
ARMCI_Group_rank(&g_even, &grp_me);
ARMCI_Group_size(&g_even, &grp_nproc);
t_abs_to_grp = MPI_Wtime();
for (i = 0; i < iter; i++)
ARMCII_Translate_absolute_to_group(&g_even, (grp_me+1) % grp_nproc);
t_abs_to_grp = MPI_Wtime() - t_abs_to_grp;
t_grp_to_abs = MPI_Wtime();
for (i = 0; i < iter; i++)
ARMCI_Absolute_id(&g_even, (grp_me+1) % grp_nproc);
t_grp_to_abs = MPI_Wtime() - t_grp_to_abs;
printf("t_abs_to_grp = %f us, t_grp_to_abs = %f us\n", t_abs_to_grp/iter * 1.0e6, t_grp_to_abs/iter * 1.0e6);
}
ARMCI_Barrier();
}
/***********************************************************************/
if (me == 0) printf(" + Freeing groups\n");
if (me % 2 > 0)
ARMCI_Group_free(&g_odd);
else
ARMCI_Group_free(&g_even);
free(procs);
ARMCI_Finalize();
MPI_Finalize();
return 0;
}
armci-mpi/benchmarks/ring-flood.c 0000644 0001750 0001750 00000004125 12662706250 016535 0 ustar mbanck mbanck /*
* Copyright (C) 2010. See COPYRIGHT in top-level directory.
*/
#include
#include
#include
#include
#include
#include
#define MAX_XFER_SIZE 8192
#define NUM_XFERS 1024
int main(int argc, char **argv) {
int me, nproc;
int msg_length, i;
double t_start, t_stop;
armci_hdl_t *handles; // Non-blocking handles (NUM_XFERS)
uint8_t *snd_buf; // Send buffer (MAX_XFER_SIZE)
uint8_t **rcv_buf; // Receive buffer (MAX_XFER_SIZE * NUM_XFERS)
MPI_Init(&argc, &argv);
ARMCI_Init();
MPI_Comm_rank(MPI_COMM_WORLD, &me);
MPI_Comm_size(MPI_COMM_WORLD, &nproc);
if (nproc < 2)
ARMCI_Error("This benchmark should be run on at least two processes", 1);
if (me == 0)
printf("ARMCI flood bandwidth test, performing %d non-blocking xfers at each size.\n\n", NUM_XFERS);
handles = malloc(NUM_XFERS*sizeof(armci_hdl_t));
rcv_buf = malloc(nproc*sizeof(void*));
ARMCI_Malloc((void*)rcv_buf, MAX_XFER_SIZE*NUM_XFERS);
snd_buf = ARMCI_Malloc_local(MAX_XFER_SIZE);
for (i = 0; i < MAX_XFER_SIZE; i++) {
snd_buf[i] = (uint8_t) me;
}
for (msg_length = 1; msg_length <= MAX_XFER_SIZE; msg_length *= 2) {
int xfer;
for (xfer = 0; xfer < NUM_XFERS; xfer++)
ARMCI_INIT_HANDLE(&handles[xfer]);
ARMCI_Barrier();
t_start = MPI_Wtime();
// Initiate puts, perform NUM_XFERS NB puts to my right neighbor
for (xfer = 0; xfer < NUM_XFERS; xfer++) {
ARMCI_NbPut(snd_buf, ((uint8_t*)rcv_buf[(me+1)%nproc])+msg_length*xfer,
msg_length, (me+1)%nproc, &handles[xfer]);
}
// Wait for completion
for (xfer = 0; xfer < NUM_XFERS; xfer++)
ARMCI_Wait(&handles[xfer]);
ARMCI_Barrier();
t_stop = MPI_Wtime();
if (me == 0)
printf("%8d bytes \t %12.8f sec \t %12.8f GB/s\n",
msg_length*NUM_XFERS, (t_stop-t_start),
(msg_length*NUM_XFERS)/(t_stop-t_start)/1.0e9);
}
ARMCI_Free(rcv_buf[me]);
free(rcv_buf);
free(handles);
ARMCI_Free_local(snd_buf);
ARMCI_Finalize();
MPI_Finalize();
return 0;
}
armci-mpi/benchmarks/ping-pong.c 0000644 0001750 0001750 00000005765 12662706250 016406 0 ustar mbanck mbanck /*
* Copyright (C) 2010. See COPYRIGHT in top-level directory.
*/
#include
#include
#include
#include
#include
#include
#define MAX_SIZE 262144
#define NUM_ROUNDS 1000
int main(int argc, char **argv) {
int me, nproc, zero, target;
int msg_length, round, i;
double t_start, t_stop;
uint8_t *snd_buf; // Send buffer (byte array)
uint8_t **rcv_buf; // Receive buffer (byte array)
MPI_Init(&argc, &argv);
ARMCI_Init();
MPI_Comm_rank(MPI_COMM_WORLD, &me);
MPI_Comm_size(MPI_COMM_WORLD, &nproc);
if (nproc < 2)
ARMCI_Error("This benchmark should be run on at least two processes", 1);
if (me == 0)
printf("ARMCI ping-pong latency test, performing %d rounds at each xfer size.\n", NUM_ROUNDS);
rcv_buf = malloc(nproc*sizeof(void*));
ARMCI_Malloc((void*)rcv_buf, MAX_SIZE);
snd_buf = ARMCI_Malloc_local(MAX_SIZE);
zero = 0;
for (i = 0; i < MAX_SIZE; i++) {
snd_buf[i] = 1;
}
for (target = 1; target < nproc; target++) {
if (me == 0) printf("\n========== Process pair: %d and %d ==========\n\n", 0, target);
for (msg_length = 1; msg_length <= MAX_SIZE; msg_length *= 2) {
ARMCI_Barrier();
t_start = MPI_Wtime();
if (me == 0 || me == target) {
// Perform NUM_ROUNDS ping-pongs
for (round = 0; round < NUM_ROUNDS*2; round++) {
int my_target = me == 0 ? target : 0;
// I am the sender
if (round % 2 == me) {
if ((round % 2 == 0 && me == 0) || (round % 2 != 0 && me != 0)) {
// Clear start and end markers for next round
#ifdef DIRECT_ACCESS
((uint8_t*)rcv_buf[me])[0] = 0;
((uint8_t*)rcv_buf[me])[msg_length-1] = 0;
#else
ARMCI_Put(&zero, &(((uint8_t*)rcv_buf[me])[0]), 1, me);
ARMCI_Put(&zero, &(((uint8_t*)rcv_buf[me])[msg_length-1]), 1, me);
#endif
ARMCI_Put(snd_buf, rcv_buf[my_target], msg_length, my_target);
ARMCI_Fence(my_target); // This is optional, we don't need notification
}
// I am the receiver
else {
#ifdef DIRECT_ACCESS
while (((volatile uint8_t*)rcv_buf[me])[0] == 0) ;
while (((volatile uint8_t*)rcv_buf[me])[msg_length-1] == 0) ;
#else
uint8_t val;
do {
ARMCI_Get(&(((uint8_t*)rcv_buf[me])[0]), &val, 1, me);
} while (val == 0);
do {
ARMCI_Get(&(((uint8_t*)rcv_buf[me])[msg_length-1]), &val, 1, me);
} while (val == 0);
#endif
}
}
}
}
ARMCI_Barrier(); // FIXME: Time here increases with nproc :(
t_stop = MPI_Wtime();
if (me == 0)
printf("%8d bytes \t %12.8f us\n", msg_length, (t_stop-t_start)/NUM_ROUNDS*1.0e6);
}
ARMCI_Barrier();
}
ARMCI_Free(rcv_buf[me]);
free(rcv_buf);
ARMCI_Free_local(snd_buf);
ARMCI_Finalize();
MPI_Finalize();
return 0;
}
armci-mpi/benchmarks/Makefile.mk 0000644 0001750 0001750 00000001651 12662706250 016400 0 ustar mbanck mbanck #
# Copyright (C) 2010. See COPYRIGHT in top-level directory.
#
check_PROGRAMS += benchmarks/ping-pong \
benchmarks/ring-flood \
benchmarks/contiguous-bench \
benchmarks/strided-bench \
benchmarks/bench_groups \
benchmarks/rmw_perf \
# end
TESTS += benchmarks/ping-pong \
benchmarks/ring-flood \
benchmarks/contiguous-bench \
benchmarks/strided-bench \
benchmarks/rmw_perf \
# end
benchmarks_ping_pong_LDADD = libarmci.la
benchmarks_ring_flood_LDADD = libarmci.la
benchmarks_contiguous_bench_LDADD = libarmci.la -lm
benchmarks_strided_bench_LDADD = libarmci.la -lm
benchmarks_bench_groups_LDADD = libarmci.la -lm
benchmarks_rmw_perf_LDADD = libarmci.la
armci-mpi/benchmarks/rmw_perf.c 0000644 0001750 0001750 00000005425 12662706250 016322 0 ustar mbanck mbanck /*
* Copyright (C) 2010. See COPYRIGHT in top-level directory.
*/
#include
#include
#include
#include
#include
#include
#ifdef USE_ARMCI_LONG
# define INC_TYPE long
# define ARMCI_OP ARMCI_FETCH_AND_ADD_LONG
#else
# define INC_TYPE int
# define ARMCI_OP ARMCI_FETCH_AND_ADD
#endif
int main(int argc, char* argv[])
{
int provided;
#ifdef __bgp__
MPI_Init_thread(&argc, &argv, MPI_THREAD_MULTIPLE, &provided);
assert(provided==MPI_THREAD_MULTIPLE);
#else
MPI_Init_thread(&argc, &argv, MPI_THREAD_SINGLE, &provided);
#endif
int rank, nproc;
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &nproc);
if (nproc<2) {
printf("This benchmark requires >1 MPI processes\n");
MPI_Finalize();
return 1;
}
ARMCI_Init();
int count = ( argc > 1 ? atoi(argv[1]) : 1000000 );
char * cfair = getenv ("CHECK_FAIRNESS");
int check_fairness = (cfair!=NULL) ? 1 : 0;
int * complete = (int *) malloc(sizeof(int) * count);
for(int i=0; i0)
{
int target = 0;
INC_TYPE val = -1;
double t0 = MPI_Wtime();
while(val < count) {
ARMCI_Rmw(ARMCI_OP, &val, base_ptrs[target], 1, target);
if (val < count) {
complete[val] = rank;
nrecv++;
}
}
double t1 = MPI_Wtime();
tt = (t1-t0);
}
MPI_Allreduce(MPI_IN_PLACE, complete, count, MPI_INT, MPI_SUM, MPI_COMM_WORLD);
double dt = 1.e6*(double)tt/(double)nrecv;
if(nrecv>0)
printf("process %d received %d counters in %lf seconds (%lf microseconds per call)\n",
rank, nrecv, tt, dt);
fflush(stdout);
MPI_Barrier(MPI_COMM_WORLD);
if (0==rank && check_fairness==1) {
printf("Checking for fairness...\n");
fflush(stdout);
for(int i=0; i
#include
#include
#include
#include
#include
#ifdef MODE_SET
#include
#endif
#define MAX_XDIM 1024
#define MAX_YDIM 1024
#define MAX_DATA_SIZE (MAX_XDIM*MAX_YDIM*sizeof(double))
#define NUM_ITERATIONS ((xdim*ydim <= 1024) ? 64 : 16)
#define NUM_WARMUP_ITER 1
int main(int argc, char ** argv) {
int rank, nproc;
#ifdef MULTIPLE
int thread_level;
#endif
int target_rank, xdim, ydim, test_iter;
int stride[1], count[2], levels;
double scale;
int *buf;
void **base_ptrs;
#ifdef MODE_SET
ARMCI_Group grp_world;
#endif
#ifdef MULTIPLE
MPI_Init_thread(&argc, &argv, MPI_THREAD_MULTIPLE, &thread_level);
#else
MPI_Init(&argc, &argv);
#endif
ARMCI_Init();
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &nproc);
if (rank == 0) printf("Starting one-sided strided performance test with %d processes\n", nproc);
buf = ARMCI_Malloc_local(MAX_DATA_SIZE);
base_ptrs = malloc(sizeof(void*)*nproc);
ARMCI_Malloc(base_ptrs, MAX_DATA_SIZE);
memset(buf, rank+1, MAX_DATA_SIZE);
#ifdef MODE_SET
ARMCI_Group_get_default(&grp_world);
if (getenv("ARMCIX_MODE_SET"))
ARMCIX_Mode_set(ARMCIX_MODE_CONFLICT_FREE | ARMCIX_MODE_NO_LOAD_STORE, base_ptrs[rank], &grp_world);
else if (rank == 0)
printf("Warning: ARMCIX_MODE_SET not enabled\n");
#endif
if (rank == 0)
printf("%12s %12s %12s %12s %12s %12s %12s %12s\n", "Trg. Rank", "Xdim Ydim",
"Get (usec)", "Put (usec)", "Acc (usec)",
"Get (MiB/s)", "Put (MiB/s)", "Acc (MiB/s)");
stride[0] = MAX_XDIM*sizeof(double);
levels = 1;
scale = 1.0;
for (target_rank = 1; rank == 0 && target_rank < nproc; target_rank++) {
for (xdim = 1; xdim <= MAX_XDIM; xdim *= 2) {
count[0] = xdim*sizeof(double);
for (ydim = 1; ydim <= MAX_YDIM; ydim *= 2) {
const int data_size = xdim*ydim*sizeof(double);
double t_get=0.0, t_put=0.0, t_acc=0.0;
count[1] = ydim;
for (test_iter = 0; test_iter < NUM_ITERATIONS + NUM_WARMUP_ITER; test_iter++) {
if (test_iter == NUM_WARMUP_ITER)
t_put = MPI_Wtime();
ARMCI_PutS(buf, stride, base_ptrs[target_rank], stride, count, levels, target_rank);
}
ARMCI_Fence(target_rank);
t_put = (MPI_Wtime() - t_put)/NUM_ITERATIONS;
for (test_iter = 0; test_iter < NUM_ITERATIONS + NUM_WARMUP_ITER; test_iter++) {
if (test_iter == NUM_WARMUP_ITER)
t_acc = MPI_Wtime();
ARMCI_AccS(ARMCI_ACC_DBL, (void*) &scale, buf, stride, base_ptrs[target_rank], stride, count, levels, target_rank);
}
ARMCI_Fence(target_rank);
t_acc = (MPI_Wtime() - t_acc)/NUM_ITERATIONS;
for (test_iter = 0; test_iter < NUM_ITERATIONS + NUM_WARMUP_ITER; test_iter++) {
if (test_iter == NUM_WARMUP_ITER)
t_get = MPI_Wtime();
ARMCI_GetS(base_ptrs[target_rank], stride, buf, stride, count, levels, target_rank);
}
t_get = (MPI_Wtime() - t_get)/NUM_ITERATIONS;
printf("%12d %6d%6d %12.3f %12.3f %12.3f %12.3f %12.3f %12.3f\n", target_rank, xdim, ydim,
t_get*1.0e6, t_put*1.0e6, t_acc*1.0e6, data_size/(1024.0*1024.0)/t_get, data_size/(1024.0*1024.0)/t_put, data_size/(1024.0*1024.0)/t_acc);
}
}
}
ARMCI_Barrier();
ARMCI_Free(base_ptrs[rank]);
ARMCI_Free_local(buf);
free(base_ptrs);
ARMCI_Finalize();
MPI_Finalize();
return 0;
}
armci-mpi/benchmarks/contiguous-bench.c 0000644 0001750 0001750 00000006425 12662706250 017756 0 ustar mbanck mbanck /*
* Copyright (C) 2010. See COPYRIGHT in top-level directory.
*/
#include
#include
#include
#include
#include
#include
#ifdef MODE_SET
#include
#endif
#define MAX_DATA_SIZE (1024*128*16)
#define NUM_ITERATIONS ((data_size <= 2048) ? 4096 : ((data_size <= 16384) ? 1024 : 512))
#define NUM_WARMUP_ITER 1
int main(int argc, char ** argv) {
int rank, nproc, test_iter, target_rank, data_size;
#ifdef MULTIPLE
inr thread_level;
#endif
int *buf;
void **base_ptrs;
#ifdef MODE_SET
ARMCI_Group grp_world;
#endif
#ifdef MULTIPLE
MPI_Init_thread(&argc, &argv, MPI_THREAD_MULTIPLE, &thread_level);
#else
MPI_Init(&argc, &argv);
#endif
ARMCI_Init();
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &nproc);
if (rank == 0) printf("Starting one-sided contiguous performance test with %d processes\n", nproc);
buf = ARMCI_Malloc_local(MAX_DATA_SIZE);
base_ptrs = malloc(sizeof(void*)*nproc);
ARMCI_Malloc(base_ptrs, MAX_DATA_SIZE);
memset(buf, rank, MAX_DATA_SIZE);
#ifdef MODE_SET
ARMCI_Group_get_default(&grp_world);
if (getenv("ARMCIX_MODE_SET"))
ARMCIX_Mode_set(ARMCIX_MODE_CONFLICT_FREE | ARMCIX_MODE_NO_LOAD_STORE, base_ptrs[rank], &grp_world);
else if (rank == 0)
printf("Warning: ARMCIX_MODE_SET not enabled\n");
#endif
if (rank == 0)
printf("%12s %12s %12s %12s %12s %12s %12s %12s\n", "Trg. Rank", "Xfer Size",
"Get (usec)", "Put (usec)", "Acc (usec)",
"Get (MiB/s)", "Put (MiB/s)", "Acc (MiB/s)");
for (target_rank = 1; rank == 0 && target_rank < nproc; target_rank++) {
for (data_size = sizeof(double); data_size <= MAX_DATA_SIZE; data_size *= 2) {
double t_get=0, t_put=0, t_acc=0;
for (test_iter = 0; test_iter < NUM_ITERATIONS + NUM_WARMUP_ITER; test_iter++) {
if (test_iter == NUM_WARMUP_ITER)
t_get = MPI_Wtime();
ARMCI_Get(base_ptrs[target_rank], buf, data_size, target_rank);
}
t_get = (MPI_Wtime() - t_get)/NUM_ITERATIONS;
for (test_iter = 0; test_iter < NUM_ITERATIONS + NUM_WARMUP_ITER; test_iter++) {
if (test_iter == NUM_WARMUP_ITER)
t_put = MPI_Wtime();
ARMCI_Put(buf, base_ptrs[target_rank], data_size, target_rank);
}
ARMCI_Fence(target_rank);
t_put = (MPI_Wtime() - t_put)/NUM_ITERATIONS;
for (test_iter = 0; test_iter < NUM_ITERATIONS + NUM_WARMUP_ITER; test_iter++) {
double scale = 1.0;
if (test_iter == NUM_WARMUP_ITER)
t_acc = MPI_Wtime();
#ifdef NO_ACC
int stride = 0;
ARMCI_AccS(ARMCI_ACC_DBL, &scale, buf, &stride, base_ptrs[target_rank], &stride, &data_size, 0, target_rank);
#else
ARMCI_Acc(ARMCI_ACC_DBL, &scale, buf, base_ptrs[target_rank], data_size, target_rank);
#endif
}
ARMCI_Fence(target_rank);
t_acc = (MPI_Wtime() - t_acc)/NUM_ITERATIONS;
printf("%12d %12d %12.3f %12.3f %12.3f %12.3f %12.3f %12.3f\n", target_rank, data_size,
t_get*1.0e6, t_put*1.0e6, t_acc*1.0e6, data_size/(1024.0*1024.0)/t_get, data_size/(1024.0*1024.0)/t_put, data_size/(1024.0*1024.0)/t_acc);
}
}
ARMCI_Barrier();
ARMCI_Free(base_ptrs[rank]);
ARMCI_Free_local(buf);
free(base_ptrs);
ARMCI_Finalize();
MPI_Finalize();
return 0;
}
armci-mpi/CHANGES 0000644 0001750 0001750 00000000136 12662706250 013205 0 ustar mbanck mbanck * r506: Added support for the ARMCI profiling interface.
* r498: Fixed a few memory leaks.
armci-mpi/m4/ 0000755 0001750 0001750 00000000000 12663426407 012536 5 ustar mbanck mbanck armci-mpi/m4/aclocal_cxx.m4 0000644 0001750 0001750 00000013056 12662706250 015261 0 ustar mbanck mbanck dnl PAC_PROG_CXX - reprioritize the C++ compiler search order
AC_DEFUN([PAC_PROG_CXX],[
PAC_PUSH_FLAG([CXXFLAGS])
AC_PROG_CXX([g++ icpc pgCC xlC pathCC cl])
PAC_POP_FLAG([CXXFLAGS])
])
dnl This is from crypt.to/autoconf-archive, slightly modified.
dnl It defines bool as int if it is not availalbe
dnl
AC_DEFUN([AC_CXX_BOOL],
[AC_CACHE_CHECK(whether the compiler recognizes bool as a built-in type,
ac_cv_cxx_bool,
[AC_LANG_SAVE
AC_LANG_CPLUSPLUS
AC_TRY_COMPILE([
int f(int x){return 1;}
int f(char x){return 1;}
int f(bool x){return 1;}
],[bool b = true; return f(b);],
ac_cv_cxx_bool=yes, ac_cv_cxx_bool=no)
AC_LANG_RESTORE
])
if test "$ac_cv_cxx_bool" != yes; then
AC_DEFINE(bool,int,[define if bool is a built-in type])
fi
])
dnl This is from crypt.to/autoconf-archive, slightly modified (name defined)
dnl
AC_DEFUN([AC_CXX_EXCEPTIONS],
[AC_CACHE_CHECK(whether the compiler supports exceptions,
ac_cv_cxx_exceptions,
[AC_LANG_SAVE
AC_LANG_CPLUSPLUS
AC_TRY_COMPILE(,[try { throw 1; } catch (int i) { return i; }],
ac_cv_cxx_exceptions=yes, ac_cv_cxx_exceptions=no)
AC_LANG_RESTORE
])
if test "$ac_cv_cxx_exceptions" = yes; then
AC_DEFINE(HAVE_CXX_EXCEPTIONS,,[define if the compiler supports exceptions])
fi
])
dnl This is from crypt.to/autoconf-archive
dnl
AC_DEFUN([AC_CXX_NAMESPACES],
[AC_CACHE_CHECK(whether the compiler implements namespaces,
ac_cv_cxx_namespaces,
[AC_LANG_SAVE
AC_LANG_CPLUSPLUS
AC_TRY_COMPILE([namespace Outer { namespace Inner { int i = 0; }}],
[using namespace Outer::Inner; return i;],
ac_cv_cxx_namespaces=yes, ac_cv_cxx_namespaces=no)
AC_LANG_RESTORE
])
if test "$ac_cv_cxx_namespaces" = yes; then
AC_DEFINE(HAVE_NAMESPACES,,[define if the compiler implements namespaces])
fi
])
dnl Some compilers support namespaces but don't know about std
dnl
AC_DEFUN([AC_CXX_NAMESPACE_STD],
[AC_REQUIRE([AC_CXX_NAMESPACES])
AC_CACHE_CHECK(whether the compiler implements the namespace std,
ac_cv_cxx_namespace_std,
[ac_cv_cxx_namespace_std=no
if test "$ac_cv_cxx_namespaces" = yes ; then
AC_LANG_SAVE
AC_LANG_CPLUSPLUS
AC_TRY_COMPILE([
#include
using namespace std;],
[cout << "message\n";],
ac_cv_cxx_namespace_std=yes, ac_cv_cxx_namespace_std=no)
AC_LANG_RESTORE
fi
])
if test "$ac_cv_cxx_namespace_std" = yes; then
AC_DEFINE(HAVE_NAMESPACE_STD,,[define if the compiler implements namespace std])
fi
])
dnl/*D
dnl PAC_CXX_CHECK_COMPILER_OPTION - Check that a C++ compiler option is
dnl accepted without warning messages
dnl
dnl Synopsis:
dnl PAC_CXX_CHECK_COMPILER_OPTION(optionname,action-if-ok,action-if-fail)
dnl
dnl Output Effects:
dnl
dnl If no actions are specified, a working value is added to 'CXXOPTIONS'
dnl
dnl Notes:
dnl This is now careful to check that the output is different, since
dnl some compilers are noisy.
dnl
dnl We are extra careful to prototype the functions in case compiler options
dnl that complain about poor code are in effect.
dnl
dnl Because this is a long script, we have ensured that you can pass a
dnl variable containing the option name as the first argument.
dnl D*/
AC_DEFUN([PAC_CXX_CHECK_COMPILER_OPTION],[
AC_MSG_CHECKING([whether C++ compiler accepts option $1])
save_CXXFLAGS="$CXXFLAGS"
CXXFLAGS="$1 $CXXFLAGS"
rm -f conftest.out
echo 'int foo(void);int foo(void){return 0;}' > conftest2.cpp
echo 'int main(void);int main(void){return 0;}' > conftest.cpp
if ${CXX-g++} $save_CXXFLAGS $CPPFLAGS -o conftest conftest.cpp $LDFLAGS >conftest.bas 2>&1 ; then
if ${CXX-g++} $CXXFLAGS $CPPFLAGS -o conftest conftest.cpp $LDFLAGS >conftest.out 2>&1 ; then
if diff -b conftest.out conftest.bas >/dev/null 2>&1 ; then
AC_MSG_RESULT(yes)
AC_MSG_CHECKING([whether routines compiled with $1 can be linked with ones compiled without $1])
rm -f conftest.out
rm -f conftest.bas
if ${CXX-g++} -c $save_CXXFLAGS $CPPFLAGS conftest2.cpp >conftest2.out 2>&1 ; then
if ${CXX-g++} $CXXFLAGS $CPPFLAGS -o conftest conftest2.o conftest.cpp $LDFLAGS >conftest.bas 2>&1 ; then
if ${CXX-g++} $CXXFLAGS $CPPFLAGS -o conftest conftest2.o conftest.cpp $LDFLAGS >conftest.out 2>&1 ; then
if diff -b conftest.out conftest.bas >/dev/null 2>&1 ; then
AC_MSG_RESULT(yes)
CXXFLAGS="$save_CXXFLAGS"
ifelse($2,,CXXOPTIONS="$CXXOPTIONS $1",$2)
elif test -s conftest.out ; then
cat conftest.out >&AC_FD_CC
AC_MSG_RESULT(no)
CXXFLAGS="$save_CXXFLAGS"
$3
else
AC_MSG_RESULT(no)
CXXFLAGS="$save_CXXFLAGS"
$3
fi
else
if test -s conftest.out ; then
cat conftest.out >&AC_FD_CC
fi
AC_MSG_RESULT(no)
CXXFLAGS="$save_CXXFLAGS"
$3
fi
else
# Could not link with the option!
AC_MSG_RESULT(no)
fi
else
if test -s conftest2.out ; then
cat conftest2.out >&AC_FD_CC
fi
AC_MSG_RESULT(no)
CXXFLAGS="$save_CXXFLAGS"
$3
fi
else
cat conftest.out >&AC_FD_CC
AC_MSG_RESULT(no)
$3
CXXFLAGS="$save_CXXFLAGS"
fi
else
AC_MSG_RESULT(no)
$3
if test -s conftest.out ; then cat conftest.out >&AC_FD_CC ; fi
CXXFLAGS="$save_CXXFLAGS"
fi
else
# Could not compile without the option!
AC_MSG_RESULT(no)
fi
rm -f conftest*
])
armci-mpi/m4/aclocal_attr_alias.m4 0000644 0001750 0001750 00000045121 12662706250 016600 0 ustar mbanck mbanck dnl
dnl Check for BSD or POSIZ style global symbol lister, nm.
dnl If found, pac_path_NM_G contains the absolute athname of nm + options
dnl pac_path_NM_G_type will be either POSIX or BSD. NM_G will be
dnl pac_path_NM_G without the absolute path. Preference is BSD style.
dnl
dnl The test checks if nm accepts the known options and also if nm produces
dnl the expected BSD or POSIX output format.
dnl
AC_DEFUN([PAC_PATH_NM_G],[
AC_MSG_CHECKING([for BSD/POSIX style global symbol lister])
AC_LANG_PUSH(C)
AC_PATH_PROGS_FEATURE_CHECK(NM_G, nm, [
# Check if nm accepts -g and BSD or POSIX compatible flag.
# Use the `sed 1q' to avoid HP-UX's unknown option message:
# nm: unknown option "B" ignored
# Tru64's nm complains that /dev/null is an invalid object file
#
# AIX's sed does not accept \+, 1) instead of doing 's|a\+||', do 's|aa*||'
# or 2) instead of 's|A \+B|AB|g', do 's|A *B|AB|g'
# Check if nm accepts -g
case `${ac_path_NM_G} -g /dev/null 2>&1 | sed '1q'` in
*/dev/null* | *'Invalid file or object type'*)
ac_path_NM_G="${ac_path_NM_G} -g"
# Check if nm accepts -B
case `${ac_path_NM_G} -B /dev/null 2>&1 | sed '1q'` in
*/dev/null* | *'Invalid file or object type'*)
AC_COMPILE_IFELSE([
AC_LANG_SOURCE([int iglobal;])
],[
changequote(,)
case `${ac_path_NM_G} -B conftest.$OBJEXT | sed -e 's|[0-9][0-9]* *[A-Z] *iglobal|XXXX|g'` in
*XXXX*)
pac_path_NM_G="${ac_path_NM_G} -B"
pac_path_NM_G_type="BSD"
;;
esac
changequote([,])
])
;;
*)
# Check if nm accepts -P
case `${ac_path_NM_G} -P /dev/null 2>&1 | sed '1q'` in
*/dev/null* | *'Invalid file or object type'*)
AC_COMPILE_IFELSE([
AC_LANG_SOURCE([int iglobal;])
],[
changequote(,)
case `${ac_path_NM_G} -P conftest.$OBJEXT | sed -e 's|iglobal *[A-Z] *[0-9][0-9]*|XXXX|g'` in
*XXXX*)
pac_path_NM_G="${ac_path_NM_G} -P"
pac_path_NM_G_type="POSIX"
;;
esac
changequote([,])
])
;;
esac # Endof case `${ac_path_NM_G} -P
;;
esac # Endof case `${ac_path_NM_G} -B
;;
esac # Endof case `${ac_path_NM_G} -g
if test "X$pac_path_NM_G" != "X" ; then
AC_MSG_RESULT([$pac_path_NM_G_type style,$pac_path_NM_G])
NM_G="`echo $pac_path_NM_G | sed -e 's|^.*nm |nm |g'`"
else
AC_MSG_RESULT(no)
fi
ac_cv_path_NM_G=${ac_path_NM_G}
ac_path_NM_G_found=:
], [AC_MSG_RESULT(no)],
[$PATH$PATH_SEPARATOR/usr/ccs/bin/elf$PATH_SEPARATOR/usr/ccs/bin$PATH_SEPARATOR/usr/ucb$PATH_SEPARATOR/bin])
AC_LANG_POP(C)
]) dnl Endof AC_DEFUN([PAC_PATH_NM_G]
dnl
dnl PAC_C_MULTI_ATTR_ALIAS()
dnl
dnl The checks if multiple __attribute__((alias)) is available
dnl If the multiple __attribute((alias)) support is found,
dnl pac_c_multi_attr_alias=yes is set.
dnl
dnl The default is to do a runtime test. When cross_compiling=yes,
dnl pac_path_NM_G will be used to determine the test result.
dnl If CFLAGS(or CPPFLAGS) contains ATTR_ALIAS_DEBUG, the runtime will print
dnl out addresses of struct(s) for debugging purpose.
dnl
dnl
AC_DEFUN([PAC_C_MULTI_ATTR_ALIAS],[
AC_REQUIRE([PAC_PATH_NM_G])
AC_LANG_PUSH(C)
AC_CHECK_HEADERS([stdio.h])
AC_MSG_CHECKING([for multiple __attribute__((alias)) support])
#Compile the "other" __attribute__ object file.
AC_COMPILE_IFELSE([
AC_LANG_SOURCE([
#if defined(HAVE_STDIO_H) || defined(STDC_HEADERS)
#include
#endif
struct mpif_cmblk_t_ { int imember; };
typedef struct mpif_cmblk_t_ mpif_cmblk_t;
/* NOT initialize these structure so it appears in BSS or as COMMON symbols */
mpif_cmblk_t mpifcmb;
mpif_cmblk_t MPIFCMB;
/*
Do the test in this file instead in the file
where __attribute__((alias)) is used.
This is needed for pgcc since pgcc seems to
define aliased symbols if they are in the same file.
*/
/*
We can't do the following comparision in one test:
ilogical = (( &mpifcmb == ptr && &MPIFCMB == ptr ) ? TRUE : FALSE) ;
because some compiler, like gcc 4.4.2's -O* optimizes the code
such that the ilogical expression is FALSE. The likely reason is that
mpifcmb and MPIFCMB are defined in the same scope in which C optimizer
may have treated them as different objects (with different addresses),
&mpifcmb != &MPIFCMB, before actually running the test and hence the
illogical expression is assumed to be always FALSE. The solution taken
here is to prevent the optimizer the opportunity to equate &mpifcmb and
&MPIFCMB (in same scope), e.g. using 2 separate tests and combine the
test results in a different scope.
*/
int same_addrs1( void *ptr );
int same_addrs1( void *ptr )
{
#if defined(ATTR_ALIAS_DEBUG)
printf( "others: addr(mpifcmb)=%p, addr(input ptr)=%p\n", &mpifcmb, ptr );
#endif
return ( &mpifcmb == ptr ? 1 : 0 );
}
int same_addrs2( void *ptr );
int same_addrs2( void *ptr )
{
#if defined(ATTR_ALIAS_DEBUG)
printf( "others: addr(MPIFCMB)=%p, addr(input ptr)=%p\n", &MPIFCMB, ptr );
#endif
return ( &MPIFCMB == ptr ? 1 : 0 );
}
])
],[
rm -f pac_conftest_other.$OBJEXT
PAC_RUNLOG([cp conftest.$OBJEXT pac_conftest_other.$OBJEXT])
test -s pac_conftest_other.$OBJEXT && pac_c_attr_alias_other=yes
dnl cp conftest.$ac_ext pac_conftest_other.$ac_ext
dnl echo
dnl echo "pac_conftest_other.$OBJEXT"
dnl nm -P -g pac_conftest_other.$OBJEXT | grep -i "mpifcmb"
],[
pac_c_attr_alias_other=no
]) dnl Endof AC_COMPILE_IFELSE
pac_c_attr_alias_main=no
if test "$pac_c_attr_alias_other" = "yes" ; then
# Save LIBS for later restoration.
saved_LIBS="$LIBS"
LIBS="pac_conftest_other.$OBJEXT $LIBS"
# Link the "other" __attribute__ object file.
AC_LINK_IFELSE([
AC_LANG_PROGRAM([
#if defined(HAVE_STDIO_H) || defined(STDC_HEADERS)
#include
#endif
struct mpif_cmblk_t_ { int imember; };
typedef struct mpif_cmblk_t_ mpif_cmblk_t;
mpif_cmblk_t mpifcmbr = {0};
extern mpif_cmblk_t MPIFCMB __attribute__ ((alias("mpifcmbr")));
extern mpif_cmblk_t mpifcmb __attribute__ ((alias("mpifcmbr")));
extern int same_addrs1( void *ptr );
extern int same_addrs2( void *ptr );
],[
int iaddr = 0;
#if defined(ATTR_ALIAS_DEBUG)
printf( "main: addr(mpifcmbr) = %p\n", &mpifcmbr );
printf( "main: addr(mpifcmb) = %p\n", &mpifcmb );
printf( "main: addr(MPIFCMB) = %p\n", &MPIFCMB );
#endif
iaddr = same_addrs1( &mpifcmbr ) && same_addrs2( &mpifcmbr );
FILE *file = fopen( "pac_conftestval", "w" );
if (!file) return 1;
fprintf( file, "%d\n", iaddr );
])
],[
rm -f pac_conftest_main$EXEEXT
PAC_RUNLOG([cp conftest$EXEEXT pac_conftest_main$EXEEXT])
test -x pac_conftest_main$EXEEXT && pac_c_attr_alias_main=yes
dnl cp conftest.$ac_ext pac_conftest_main.$ac_ext
dnl echo
dnl echo "pac_conftest_main$EXEEXT"
dnl nm -P -g pac_conftest_main$EXEEXT | grep -i "mpifcmb"
],[
pac_c_attr_alias_main=no
dnl cp conftest.$ac_ext pac_conftest_main.$ac_ext
]) dnl Endof AC_LINK_IFELSE
# Restore the previously saved LIBS
LIBS="$saved_LIBS"
rm -f pac_conftest_other.$OBJEXT
fi dnl Endof if test "$pac_c_attr_alias_other" = "yes"
if test "$pac_c_attr_alias_main" = "yes" ; then
if test "$cross_compiling" = "yes" ; then
changequote(,)
# echo "PAC CROSS-COMPILING" dnl
# POSIX NM = nm -P format dnl
if test "$pac_path_NM_G_type" = "POSIX" ; then
addrs=`${pac_path_NM_G} ./pac_conftest_main$EXEEXT | grep -i mpifcmb | sed -e 's% *[a-zA-Z][a-zA-Z]* *[a-zA-Z] *\([0-9abcdef][0-9abcdef]*\).*%\1%g'`
fi
# BSD NM = nm -B format dnl
if test "$pac_path_NM_G_type" = "BSD" ; then
addrs=`${pac_path_NM_G} -g ./pac_conftest_main$EXEEXT | grep -i mpifcmb | sed -e "s% *\([0-9abcdef][0-9abcdef]*\) *[a-zA-Z] *[a-zA-Z][a-zA-A]*.*%\1%g"`
fi
changequote([,])
cmp_addr=""
diff_addrs=no
for addr in ${addrs} ; do
if test "X${cmp_addr}" != "X" ; then
if test "${cmp_addr}" != "${addr}" ; then
diff_addrs=yes
break
fi
else
cmp_addr=${addr}
fi
done
if test "$diff_addrs" != "yes" ; then
dnl echo "Same addresses. Multiple aliases support"
AC_MSG_RESULT([${NM_G} says yes])
pac_c_multi_attr_alias=yes
else
dnl echo "Different addresses. No multiple aliases support."
AC_MSG_RESULT([${NM_G} says no])
pac_c_multi_attr_alias=no
fi
else # if test "$cross_compiling" != "yes"
rm -f pac_conftestval
ac_try="./pac_conftest_main$EXEEXT"
if AC_TRY_EVAL(ac_try) ; then
pac_c_attr_alias_val=0
if test -s pac_conftestval ; then
eval pac_c_attr_alias_val=`cat pac_conftestval`
fi
if test "$pac_c_attr_alias_val" -eq 1 ; then
AC_MSG_RESULT(yes)
pac_c_multi_attr_alias=yes
else
AC_MSG_RESULT(no)
pac_c_multi_attr_alias=no
fi
rm -f pac_conftestval
fi
fi
dnl Endof if test "$cross_compiling" = "yes"
rm -f pac_conftest_main$EXEEXT
else
AC_MSG_RESULT(no! link failure)
pac_c_multi_attr_alias=no
fi dnl Endof if test "$pac_c_attr_alias_main" = "yes"
AC_LANG_POP(C)
]) dnl Endof AC_DEFUN([PAC_C_MULTI_ATTR_ALIAS]
dnl
dnl PAC_C_ATTR_ALIGNED()
dnl
dnl Check if __attribute__((aligned)) support is there.
dnl If so, set pac_c_attr_aligned=yes.
dnl
dnl Do a link test instead of compile test to check if the linker
dnl would emit an error.
dnl
AC_DEFUN([PAC_C_ATTR_ALIGNED],[
AC_LANG_PUSH(C)
AC_MSG_CHECKING([for __attribute__((aligned)) support])
#Link the __attribute__ object file.
AC_LINK_IFELSE([
AC_LANG_PROGRAM([
struct mpif_cmblk_t_ { int imembers[5]; };
typedef struct mpif_cmblk_t_ mpif_cmblk_t;
mpif_cmblk_t mpifcmbr __attribute__((aligned)) = {0};
],[])
],[pac_c_attr_aligned=yes], [pac_c_attr_aligned=no])
AC_MSG_RESULT([$pac_c_attr_aligned])
AC_LANG_POP(C)
])
dnl
dnl PAC_F2C_ATTR_ALIGNED_SIZE(ARRAY_SIZE, [OUTPUT_VAR], [MIN_ALIGNMENT])
dnl
dnl ARRAY_SIZE : Size of the integer array within the fortran commmon block.
dnl OUTPUT_VAR : Optional variable to be set.
dnl if test succeeds, set OUTPUT_VAR=$pac_f2c_attr_aligned_str.
dnl if test fails, set OUTPUT_VAR="unknown".
dnl MIN_ALIGNMENT : Optional value.
dnl Minimum alignment size to be used in OUTPUT_VAR.
dnl pac_f2c_attr_aligned_str won't be modified.
dnl
dnl "pac_f2c_attr_aligned_str" will be set with
dnl 1) __attribute__((aligned(ALIGNMENT_SIZE))),
dnl 2) __attribute__((aligned)).
dnl 3) "", i.e. empty string.
dnl
dnl 2) means the test can't find a good alignment value, but both the Fortran
dnl and C compilers are OK with "aligned" which in principle means the C
dnl compiler will pick the maximum useful alignment supported by the
dnl architecture.
dnl 3) means that the test has failed to find the alignment.
dnl
AC_DEFUN([PAC_F2C_ATTR_ALIGNED_SIZE],[
cmblksize=$1
AC_MSG_CHECKING([the minimum alignment of Fortran common block of $cmblksize integers])
dnl To find the minmium alignment of Fortran common block (of integer array)
dnl as seen by C object file, C object files of various (typical) alignments
dnl are linked to the Fortran code using the common block of integer array.
#
dnl Since the incorrect alignment results only a warning messages from the
dnl fortran compiler(or linker), so we use "diff" to compare the fortran
dnl compiler/linker output. We cannot use AC_LANG_WERROR,
dnl i.e. ac_fc_werror_flag=yes, because compiler like pgf77 at version 10.x)
dnl has non-zero stderr output if a fortran program is used in the linking.
dnl The stderr contains the name of fortran program even if the linking is
dnl successful. We could avoid the non-zero stderr output in pgf77 by
dnl compiling everthing into object files and linking all the object files
dnl with pgf77. Doing that would need us to use AC_TRY_EVAL instead of
dnl AC_LINK_IFELSE, so "diff" approach is used instead.
#
dnl Using diff of compiler(linker) output requires a reference output file
dnl as the base of diff. The process of creating this reference output file
dnl has to be exactly the same as the testing process, because pgf77 has
dnl the following weird behavour
dnl pgf77 -o ftest ftest.f => when $?=0 with zero stderr output
dnl pgf77 -o ftest ftest.f dummy.o => when $?=0 with non-zero stderr output.
dnl stderr has "ftest.f:".
dnl
# First create a fortran CONFTEST which will be used repeatedly.
AC_LANG_PUSH([Fortran]) dnl AC_LANG_PUSH([Fortran 77])
AC_LANG_CONFTEST([
AC_LANG_SOURCE([
program fconftest
integer isize
parameter (isize=$cmblksize)
integer status_array(isize)
common /mpifcmb/ status_array
save /mpifcmb/
end
])
])
AC_LANG_POP([Fortran]) dnl AC_LANG_POP([Fortran 77])
dnl
dnl
dnl
# Compile a C dummy.$OBJEXT and link with Fortran test program to create
# a reference linker output file, pac_align0.log, as the base of "diff".
AC_LANG_PUSH([C])
AC_COMPILE_IFELSE([AC_LANG_SOURCE([])],[
cp conftest.$ac_ext pac_conftest.c
PAC_RUNLOG([mv conftest.$OBJEXT pac_conftest.$OBJEXT])
saved_LIBS="$LIBS"
LIBS="pac_conftest.$OBJEXT $LIBS"
AC_LANG_PUSH([Fortran]) dnl AC_LANG_PUSH([Fortran 77])
saved_ac_link="$ac_link"
ac_link="`echo $saved_ac_link | sed -e 's|>.*$|> $pac_logfile 2>\&1|g'`"
pac_logfile="pac_align0.log"
rm -f $pac_logfile
AC_LINK_IFELSE([],[
pac_f2c_alignedn_diffbase=yes
],[
pac_f2c_alignedn_diffbase=no
])
# Be sure NOT to remove the conftest.f which is still needed for later use.
# rm -f conftest.$ac_ext
# Restore everything in autoconf that has been overwritten
ac_link="$saved_ac_link"
# restore previously saved LIBS
LIBS="$saved_LIBS"
AC_LANG_POP([Fortran]) dnl AC_LANG_POP([Fortran 77])
],[
pac_f2c_alignedn_diffbase=no
])
AC_LANG_POP([C])
dnl
dnl
if test "$pac_f2c_alignedn_diffbase" = "yes" ; then
# Initialize pac_result_str to empty string since part of the test
# depends on pac_result_str is empty or non-empty string.
pac_result_str=""
# Initialize pac_f2c_attr_aligned_str to empty string and
# it will remain as empty string if the following test fails.
pac_f2c_attr_aligned_str=""
for asize in 4 8 16 32 64 128 max ; do
if test "$asize" != "max" ; then
pac_attr_aligned_str="__attribute__((aligned($asize)))"
else
pac_attr_aligned_str="__attribute__((aligned))"
fi
AC_LANG_PUSH([C])
#Compile the __attribute__ object file.
AC_COMPILE_IFELSE([
AC_LANG_SOURCE([
changequote(,)
struct mpif_cmblk_t_ { $MPI_FINT imembers[$cmblksize]; };
changequote([,])
typedef struct mpif_cmblk_t_ mpif_cmblk_t;
mpif_cmblk_t mpifcmbr $pac_attr_aligned_str = {0};
extern mpif_cmblk_t _CMPIFCMB __attribute__ ((alias("mpifcmbr")));
extern mpif_cmblk_t MPIFCMB __attribute__ ((alias("mpifcmbr")));
extern mpif_cmblk_t MPIFCMB_ __attribute__ ((alias("mpifcmbr")));
extern mpif_cmblk_t _Cmpifcmb __attribute__ ((alias("mpifcmbr")));
extern mpif_cmblk_t mpifcmb __attribute__ ((alias("mpifcmbr")));
extern mpif_cmblk_t mpifcmb_ __attribute__ ((alias("mpifcmbr")));
])
],[
cp conftest.$ac_ext pac_conftest.c
PAC_RUNLOG([mv conftest.$OBJEXT pac_conftest.$OBJEXT])
saved_LIBS="$LIBS"
LIBS="pac_conftest.$OBJEXT $LIBS"
AC_LANG_PUSH([Fortran]) dnl AC_LANG_PUSH([Fortran 77])
saved_ac_link="$ac_link"
ac_link="`echo $saved_ac_link | sed -e 's|>.*$|> $pac_logfile 2>\&1|g'`"
pac_logfile="pac_align1.log"
rm -f $pac_logfile
# Use conftest.f created in CONFTEST.
AC_LINK_IFELSE([],[
PAC_RUNLOG_IFELSE([diff -b pac_align0.log pac_align1.log],[
pac_attr_alignedn=yes
],[
pac_attr_alignedn=no
cat $pac_logfile >&AS_MESSAGE_LOG_FD
echo "failed C program was:" >&AS_MESSAGE_LOG_FD
cat pac_conftest.c >&AS_MESSAGE_LOG_FD
echo "failed Fortran program was:" >&AS_MESSAGE_LOG_FD
cat conftest.$ac_ext >&AS_MESSAGE_LOG_FD
])
],[
pac_attr_alignedn=no
])
# Restore everything in autoconf that has been overwritten
ac_link="$saved_ac_link"
# restore previously saved LIBS
LIBS="$saved_LIBS"
AC_LANG_POP([Fortran]) dnl AC_LANG_POP([Fortran 77])
# remove previously generated object file and C file.
rm -f pac_conftest.$OBJEXT pac_conftest.c
rm -f $pac_logfile
if test "$pac_attr_alignedn" = yes ; then
ifelse([$3],[],[
pac_result_str="$asize"
pac_f2c_attr_aligned_str="$pac_attr_aligned_str"
break
],[
if test "$asize" != "max" -a "$asize" -lt "$3" ; then
if test "X$pac_result_str" = "X" ; then
pac_result_str="$asize"
pac_f2c_attr_aligned_str="$pac_attr_aligned_str"
fi
continue
else
pac_f2c_attr_aligned_str="$pac_attr_aligned_str"
if test "X$pac_result_str" != "X" ; then
pac_result_str="$pac_result_str, too small! reset to $asize"
else
pac_result_str="$asize"
fi
break
fi
])
fi
], [
pac_attr_alignedn=no
])
AC_LANG_POP([C])
done
ifelse([$2],[],[],[$2="$pac_f2c_attr_aligned_str"])
else
pac_result_str=""
# Since the test fails, set pac_f2c_attr_aligned_str to empty string.
pac_f2c_attr_aligned_str=""
fi
if test "X$pac_result_str" != "X" ; then
AC_MSG_RESULT([$pac_result_str])
else
AC_MSG_RESULT([unknown])
fi
rm -f pac_align0.log
])
dnl
armci-mpi/m4/ax_prefix_config_h.m4 0000644 0001750 0001750 00000021700 12662706250 016615 0 ustar mbanck mbanck # ===========================================================================
# http://autoconf-archive.cryp.to/ax_prefix_config_h.html
# ===========================================================================
#
# SYNOPSIS
#
# AX_PREFIX_CONFIG_H [(OUTPUT-HEADER [,PREFIX [,ORIG-HEADER]])]
#
# DESCRIPTION
#
# This is a new variant from ac_prefix_config_ this one will use a
# lowercase-prefix if the config-define was starting with a
# lowercase-char, e.g. "#define const", "#define restrict", or "#define
# off_t", (and this one can live in another directory, e.g.
# testpkg/config.h therefore I decided to move the output-header to be the
# first arg)
#
# takes the usual config.h generated header file; looks for each of the
# generated "#define SOMEDEF" lines, and prefixes the defined name (ie.
# makes it "#define PREFIX_SOMEDEF". The result is written to the output
# config.header file. The PREFIX is converted to uppercase for the
# conversions.
#
# Defaults:
#
# OUTPUT-HEADER = $PACKAGE-config.h
# PREFIX = $PACKAGE
# ORIG-HEADER, from AM_CONFIG_HEADER(config.h)
#
# Your configure.ac script should contain both macros in this order, and
# unlike the earlier variations of this prefix-macro it is okay to place
# the AX_PREFIX_CONFIG_H call before the AC_OUTPUT invokation.
#
# Example:
#
# AC_INIT(config.h.in) # config.h.in as created by "autoheader"
# AM_INIT_AUTOMAKE(testpkg, 0.1.1) # makes #undef VERSION and PACKAGE
# AM_CONFIG_HEADER(config.h) # prep config.h from config.h.in
# AX_PREFIX_CONFIG_H(mylib/_config.h) # prep mylib/_config.h from it..
# AC_MEMORY_H # makes "#undef NEED_MEMORY_H"
# AC_C_CONST_H # makes "#undef const"
# AC_OUTPUT(Makefile) # creates the "config.h" now
# # and also mylib/_config.h
#
# if the argument to AX_PREFIX_CONFIG_H would have been omitted then the
# default outputfile would have been called simply "testpkg-config.h", but
# even under the name "mylib/_config.h" it contains prefix-defines like
#
# #ifndef TESTPKG_VERSION
# #define TESTPKG_VERSION "0.1.1"
# #endif
# #ifndef TESTPKG_NEED_MEMORY_H
# #define TESTPKG_NEED_MEMORY_H 1
# #endif
# #ifndef _testpkg_const
# #define _testpkg_const _const
# #endif
#
# and this "mylib/_config.h" can be installed along with other
# header-files, which is most convenient when creating a shared library
# (that has some headers) where some functionality is dependent on the
# OS-features detected at compile-time. No need to invent some
# "mylib-confdefs.h.in" manually. :-)
#
# Note that some AC_DEFINEs that end up in the config.h file are actually
# self-referential - e.g. AC_C_INLINE, AC_C_CONST, and the AC_TYPE_OFF_T
# say that they "will define inline|const|off_t if the system does not do
# it by itself". You might want to clean up about these - consider an
# extra mylib/conf.h that reads something like:
#
# #include
# #ifndef _testpkg_const
# #define _testpkg_const const
# #endif
#
# and then start using _testpkg_const in the header files. That is also a
# good thing to differentiate whether some library-user has starting to
# take up with a different compiler, so perhaps it could read something
# like this:
#
# #ifdef _MSC_VER
# #include
# #else
# #include
# #endif
# #ifndef _testpkg_const
# #define _testpkg_const const
# #endif
#
# LAST MODIFICATION
#
# 2008-04-12
#
# COPYLEFT
#
# Copyright (c) 2008 Guido U. Draheim
# Copyright (c) 2008 Marten Svantesson
# Copyright (c) 2008 Gerald Point
#
# This program is free software; you can redistribute it and/or modify it
# under the terms of the GNU General Public License as published by the
# Free Software Foundation; either version 2 of the License, or (at your
# option) any later version.
#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
# Public License for more details.
#
# You should have received a copy of the GNU General Public License along
# with this program. If not, see .
#
# As a special exception, the respective Autoconf Macro's copyright owner
# gives unlimited permission to copy, distribute and modify the configure
# scripts that are the output of Autoconf when processing the Macro. You
# need not follow the terms of the GNU General Public License when using
# or distributing such scripts, even though portions of the text of the
# Macro appear in them. The GNU General Public License (GPL) does govern
# all other use of the material that constitutes the Autoconf Macro.
#
# This special exception to the GPL applies to versions of the Autoconf
# Macro released by the Autoconf Macro Archive. When you make and
# distribute a modified version of the Autoconf Macro, you may extend this
# special exception to the GPL to apply to your modified version as well.
AC_DEFUN([AX_PREFIX_CONFIG_H],[dnl
AC_BEFORE([AC_CONFIG_HEADERS],[$0])dnl
AC_CONFIG_COMMANDS([ifelse($1,,$PACKAGE-config.h,$1)],[dnl
AS_VAR_PUSHDEF([_OUT],[ac_prefix_conf_OUT])dnl
AS_VAR_PUSHDEF([_DEF],[ac_prefix_conf_DEF])dnl
AS_VAR_PUSHDEF([_PKG],[ac_prefix_conf_PKG])dnl
AS_VAR_PUSHDEF([_LOW],[ac_prefix_conf_LOW])dnl
AS_VAR_PUSHDEF([_UPP],[ac_prefix_conf_UPP])dnl
AS_VAR_PUSHDEF([_INP],[ac_prefix_conf_INP])dnl
m4_pushdef([_script],[conftest.prefix])dnl
m4_pushdef([_symbol],[m4_cr_Letters[]m4_cr_digits[]_])dnl
_OUT=`echo ifelse($1, , $PACKAGE-config.h, $1)`
_DEF=`echo _$_OUT | sed -e "y:m4_cr_letters:m4_cr_LETTERS[]:" -e "s/@<:@^m4_cr_Letters@:>@/_/g"`
_PKG=`echo ifelse($2, , $PACKAGE, $2)`
_LOW=`echo _$_PKG | sed -e "y:m4_cr_LETTERS-:m4_cr_letters[]_:"`
_UPP=`echo $_PKG | sed -e "y:m4_cr_letters-:m4_cr_LETTERS[]_:" -e "/^@<:@m4_cr_digits@:>@/s/^/_/"`
_INP=`echo "ifelse($3,,,$3)" | sed -e 's/ *//'`
if test ".$_INP" = "."; then
for ac_file in : $CONFIG_HEADERS; do test "_$ac_file" = _: && continue
case "$ac_file" in
*.h) _INP=$ac_file ;;
*)
esac
test ".$_INP" != "." && break
done
fi
if test ".$_INP" = "."; then
case "$_OUT" in
*/*) _INP=`basename "$_OUT"`
;;
*-*) _INP=`echo "$_OUT" | sed -e "s/@<:@_symbol@:>@*-//"`
;;
*) _INP=config.h
;;
esac
fi
if test -z "$_PKG" ; then
AC_MSG_ERROR([no prefix for _PREFIX_PKG_CONFIG_H])
else
if test ! -f "$_INP" ; then if test -f "$srcdir/$_INP" ; then
_INP="$srcdir/$_INP"
fi fi
AC_MSG_NOTICE(creating $_OUT - prefix $_UPP for $_INP defines)
if test -f $_INP ; then
echo "s/^@%:@undef *\\(@<:@m4_cr_LETTERS[]_@:>@\\)/@%:@undef $_UPP""_\\1/" > _script
echo "s/^@%:@undef *\\(@<:@m4_cr_letters@:>@\\)/@%:@undef $_LOW""_\\1/" >> _script
echo "s/^@%:@def[]ine *\\(@<:@m4_cr_LETTERS[]_@:>@@<:@_symbol@:>@*\\)\\(.*\\)/@%:@ifndef $_UPP""_\\1 \\" >> _script
echo "@%:@def[]ine $_UPP""_\\1 \\2 \\" >> _script
echo "@%:@endif/" >>_script
echo "s/^@%:@def[]ine *\\(@<:@m4_cr_letters@:>@@<:@_symbol@:>@*\\)\\(.*\\)/@%:@ifndef $_LOW""_\\1 \\" >> _script
echo "@%:@define $_LOW""_\\1 \\2 \\" >> _script
echo "@%:@endif/" >> _script
# now executing _script on _DEF input to create _OUT output file
echo "@%:@ifndef $_DEF" >$tmp/pconfig.h
echo "@%:@def[]ine $_DEF 1" >>$tmp/pconfig.h
echo ' ' >>$tmp/pconfig.h
echo /'*' $_OUT. Generated automatically at end of configure. '*'/ >>$tmp/pconfig.h
sed -f _script $_INP >>$tmp/pconfig.h
echo ' ' >>$tmp/pconfig.h
echo '/* once:' $_DEF '*/' >>$tmp/pconfig.h
echo "@%:@endif" >>$tmp/pconfig.h
if cmp -s $_OUT $tmp/pconfig.h 2>/dev/null; then
AC_MSG_NOTICE([$_OUT is unchanged])
else
ac_dir=`AS_DIRNAME(["$_OUT"])`
AS_MKDIR_P(["$ac_dir"])
rm -f "$_OUT"
mv $tmp/pconfig.h "$_OUT"
fi
cp _script _configs.sed
else
AC_MSG_ERROR([input file $_INP does not exist - skip generating $_OUT])
fi
rm -f conftest.*
fi
m4_popdef([_symbol])dnl
m4_popdef([_script])dnl
AS_VAR_POPDEF([_INP])dnl
AS_VAR_POPDEF([_UPP])dnl
AS_VAR_POPDEF([_LOW])dnl
AS_VAR_POPDEF([_PKG])dnl
AS_VAR_POPDEF([_DEF])dnl
AS_VAR_POPDEF([_OUT])dnl
],[PACKAGE="$PACKAGE"])])
dnl implementation note: a bug report (31.5.2005) from Marten Svantesson points
dnl out a problem where `echo "\1"` results in a Control-A. The unix standard
dnl http://www.opengroup.org/onlinepubs/000095399/utilities/echo.html
dnl defines all backslash-sequences to be inherently non-portable asking
dnl for replacement mit printf. Some old systems had problems with that
dnl one either. However, the latest libtool (!) release does export an $ECHO
dnl (and $echo) that does the right thing - just one question is left: what
dnl was the first version to have it? Is it greater 2.58 ?
armci-mpi/m4/ax_tls.m4 0000644 0001750 0001750 00000006256 12662706250 014277 0 ustar mbanck mbanck # ===========================================================================
# http://www.nongnu.org/autoconf-archive/ax_tls.html
# ===========================================================================
#
# SYNOPSIS
#
# AX_TLS
#
# DESCRIPTION
#
# Provides a test for the compiler support of thread local storage (TLS)
# extensions. Defines TLS if it is found. Currently only knows about GCC
# and MSVC. I think SunPro uses the same as GCC, and Borland apparently
# supports either.
#
# LICENSE
#
# Copyright (c) 2008 Alan Woodland
#
# This program is free software: you can redistribute it and/or modify it
# under the terms of the GNU General Public License as published by the
# Free Software Foundation, either version 3 of the License, or (at your
# option) any later version.
#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
# Public License for more details.
#
# You should have received a copy of the GNU General Public License along
# with this program. If not, see .
#
# As a special exception, the respective Autoconf Macro's copyright owner
# gives unlimited permission to copy, distribute and modify the configure
# scripts that are the output of Autoconf when processing the Macro. You
# need not follow the terms of the GNU General Public License when using
# or distributing such scripts, even though portions of the text of the
# Macro appear in them. The GNU General Public License (GPL) does govern
# all other use of the material that constitutes the Autoconf Macro.
#
# This special exception to the GPL applies to versions of the Autoconf
# Macro released by the Autoconf Archive. When you make and distribute a
# modified version of the Autoconf Macro, you may extend this special
# exception to the GPL to apply to your modified version as well.
AC_DEFUN([AX_TLS], [
AC_MSG_CHECKING(for thread local storage specifier)
AC_CACHE_VAL(ac_cv_tls, [
ax_tls_keywords="__thread __declspec(thread) none"
for ax_tls_keyword in $ax_tls_keywords; do
case $ax_tls_keyword in
none) ac_cv_tls=none ; break ;;
*)
# MPICH2 modification: This was an AC_TRY_COMPILE before, but
# Darwin with non-standard compilers will accept __thread at
# compile time but fail to link due to an undefined
# "__emutls_get_address" symbol unless -lgcc_eh is added to the
# link line.
AC_LINK_IFELSE(
[AC_LANG_PROGRAM([$ax_tls_keyword int bar = 5;],[++bar;])],
[ac_cv_tls=$ax_tls_keyword ; break],
[ac_cv_tls=none])
esac
done
])
if test "$ac_cv_tls" != "none"; then
# MPICH2 modification: this was "TLS" before instead of
# "MPIU_TLS_SPECIFIER", but TLS had a reasonably high chance of conflicting
# with a system library.
AC_DEFINE_UNQUOTED([MPIU_TLS_SPECIFIER], $ac_cv_tls, [If the compiler supports a TLS storage class define it to that here])
fi
AC_MSG_RESULT($ac_cv_tls)
])
armci-mpi/m4/aclocal_am.m4 0000644 0001750 0001750 00000000547 12662706250 015055 0 ustar mbanck mbanck dnl AM_IGNORE is an extension that tells (a patched) automake not to
dnl include the specified AC_SUBST variable in the Makefile.in that
dnl automake generates. We don't use AC_DEFUN, since aclocal will
dnl then complain that AM_IGNORE is a duplicate (if you are using the
dnl patched automake/aclocal).
m4_ifdef([AM_IGNORE],[],[m4_define([AM_IGNORE],[])])
armci-mpi/m4/aclocal_fc.m4 0000644 0001750 0001750 00000072743 12662706250 015057 0 ustar mbanck mbanck dnl /*D
dnl PAC_PROG_FC([COMPILERS])
dnl
dnl COMPILERS is a space separated list of Fortran 77 compilers to search
dnl for. Fortran 95 isn't strictly backwards-compatible with Fortran 77,
dnl but `f95' is worth trying.
dnl
dnl Compilers are ordered by
dnl 1. F77, F90, F95
dnl 2. Good/tested native compilers, bad/untested native compilers
dnl 3. Wrappers around f2c go last.
dnl
dnl `fort77' is a wrapper around `f2c'.
dnl It is believed that under HP-UX `fort77' is the name of the native
dnl compiler. On some Cray systems, fort77 is a native compiler.
dnl frt is the Fujitsu F77 compiler.
dnl pgf77 and pgf90 are the Portland Group F77 and F90 compilers.
dnl xlf/xlf90/xlf95 are IBM (AIX) F77/F90/F95 compilers.
dnl lf95 is the Lahey-Fujitsu compiler.
dnl fl32 is the Microsoft Fortran "PowerStation" compiler.
dnl af77 is the Apogee F77 compiler for Intergraph hardware running CLIX.
dnl epcf90 is the "Edinburgh Portable Compiler" F90.
dnl fort is the Compaq Fortran 90 (now 95) compiler for Tru64 and Linux/Alpha.
dnl pathf90 is the Pathscale Fortran 90 compiler
dnl ifort is another name for the Intel f90 compiler
dnl efc - An older Intel compiler (?)
dnl ifc - An older Intel compiler
dnl fc - A compiler on some unknown system. This has been removed because
dnl it may also be the name of a command for something other than
dnl the Fortran compiler (e.g., fc=file system check!)
dnl D*/
AC_DEFUN([PAC_PROG_FC],[
PAC_PUSH_FLAG([FCFLAGS])
AC_PROG_FC([m4_default([$1],
[ifort pgf90 pathf90 pathf95 xlf90 xlf95 f90 epcf90 f95 fort lf95 \
gfortran g95 ifc efc])])
PAC_POP_FLAG([FCFLAGS])
])
dnl
dnl PAC_FC_EXT checks for the default Fortran 90 program extension, f90 then f.
dnl This could be replaced by AC_FC_SRCEXT but since AC_FC_SRCEXT
dnl adds FCFLAGS_ext, which is used to modify FCFLAGS or Makefile.in.
dnl So will do this later.
dnl
AC_DEFUN([PAC_FC_EXT],[
AC_MSG_CHECKING([for extension for Fortran 90 programs])
ac_fc_srcext="f90"
AC_LANG_PUSH(Fortran)
AC_COMPILE_IFELSE([
AC_LANG_PROGRAM()
],[
AC_MSG_RESULT([f90])
],[
ac_fc_srcext="f"
AC_COMPILE_IFELSE([
AC_LANG_PROGRAM()
],[
AC_MSG_RESULT([f])
],[
AC_MSG_RESULT([unknown!])
])
])
AC_LANG_POP(Fortran)
])
dnl
dnl Internal routine for testing F90
dnl PAC_PROG_FC_WORKS()
dnl
AC_DEFUN([PAC_PROG_FC_WORKS],[
AC_REQUIRE([PAC_FC_EXT])
AC_LANG_PUSH(Fortran)
AC_MSG_CHECKING([whether the Fortran 90 compiler ($FC $FCFLAGS $LDFLAGS) works])
AC_LINK_IFELSE([
AC_LANG_SOURCE([
program conftest
integer, dimension(10) :: n
end
])
],[
pac_cv_prog_fc_works="yes"
AC_MSG_RESULT([$pac_cv_prog_fc_works])
AC_MSG_CHECKING([whether the Fortran 90 compiler ($FC $FCFLAGS $LDFLAGS) is a cross-compiler])
AC_RUN_IFELSE([],
[pac_cv_prog_fc_cross="no"],
[pac_cv_prog_fc_cross="yes"],
[pac_cv_prog_fc_cross="$cross_compiling"]
)
AC_MSG_RESULT($pac_cv_prog_fc_cross)
],[
pac_cv_prog_fc_works="no"
AC_MSG_WARN([installation or configuration problem: Fortran 90 compiler cannot create executables.])
])
# The intel compiler sometimes generates these work.pc and .pcl files
rm -f work.pc work.pcl
AC_LANG_POP(Fortran)
dnl cross_compiling no longer maintained by autoconf as part of the
dnl AC_LANG changes. If we set it here, a later AC_LANG may not
dnl restore it (in the case where one compiler claims to be a cross compiler
dnl and another does not)
dnl cross_compiling=$pac_cv_prog_f90_cross
])
dnl/*D
dnl PAC_PROG_FC_INT_KIND - Determine kind parameter for an integer with
dnl the specified number of bytes.
dnl
dnl Synopsis:
dnl PAC_PROG_FC_INT_KIND(variable-to-set,number-of-bytes,[cross-size])
dnl
dnl D*/
AC_DEFUN([PAC_PROG_FC_INT_KIND],[
# Set the default
$1=-1
if test "$pac_cv_prog_fc_cross" = "yes" ; then
$1="$3"
else
AC_LANG_PUSH(Fortran)
AC_MSG_CHECKING([for Fortran 90 integer kind for $2-byte integers])
# Convert bytes to digits
case $2 in
1) sellen=2 ;;
2) sellen=4 ;;
4) sellen=8 ;;
8) sellen=16 ;;
16) sellen=30 ;;
*) sellen=8 ;;
esac
# Check for cached value
eval testval=\$"pac_cv_prog_fc_int_kind_$sellen"
if test -n "$testval" ; then
AC_MSG_RESULT([$testval (cached)])
$1=$testval
else
KINDVAL="unavailable"
eval "pac_cv_prog_fc_int_kind_$sellen"=-1
AC_RUN_IFELSE([
AC_LANG_SOURCE([
program main
integer ii
ii = selected_int_kind($sellen)
open(8, file="conftest1.out", form="formatted")
write (8,*) ii
close(8)
stop
end
])
],[pac_run_ok=yes],[pac_run_ok=no])
if test "$pac_run_ok" = "yes" ; then
if test -s conftest1.out ; then
# Because of write, there may be a leading blank.
KINDVAL=`cat conftest1.out | sed 's/ //g'`
eval "pac_cv_prog_fc_int_kind_$sellen"=$KINDVAL
$1=$KINDVAL
fi
fi
AC_MSG_RESULT([$KINDVAL])
fi # not cached
AC_LANG_POP(Fortran)
fi # is not cross compiling
])dnl
dnl
dnl ------------------------------------------------------------------------
dnl Special characteristics that have no autoconf counterpart but that
dnl we need as part of the Fortran 90 support. To distinquish these, they
dnl have a [PAC] prefix.
dnl
dnl
dnl PAC_FC_MODULE_EXT(action if found,action if not found)
dnl
AC_DEFUN([PAC_FC_MODULE_EXT],
[AC_CACHE_CHECK([for Fortran 90 module extension],
pac_cv_fc_module_ext,[
pac_cv_fc_module_case="unknown"
AC_LANG_PUSH(Fortran)
AC_COMPILE_IFELSE([
AC_LANG_SOURCE([
module conftest
integer n
parameter (n=1)
end module conftest
])
],[
dnl Look for module name
dnl First, try to find known names. This avoids confusion caused by
dnl additional files (like .stb created by some versions of pgf90)
dnl Early versions of the Intel compiler used "d" as the module extension;
dnl we include that just to finish the test as early as possible.
for name in conftest CONFTEST ; do
for ext in mod MOD d ; do
if test -s $name.$ext ; then
if test $name = conftest ; then
pac_cv_fc_module_case=lower
else
pac_cv_fc_module_case=upper
fi
pac_cv_fc_module_ext=$ext
pac_MOD=$ext
break
fi
done
if test -n "$pac_cv_fc_module_ext" ; then break ; fi
done
if test -z "$pac_MOD" ; then
pac_MOD=`ls conftest.* 2>&1 | grep -v conftest.${ac_fc_srcext} | grep -v conftest.o`
pac_MOD=`echo $pac_MOD | sed -e 's/conftest\.//g'`
pac_cv_fc_module_case="lower"
if test "X$pac_MOD" = "X" ; then
pac_MOD=`ls CONFTEST* 2>&1 | grep -v CONFTEST.f | grep -v CONFTEST.o`
pac_MOD=`echo $pac_MOD | sed -e 's/CONFTEST\.//g'`
if test -n "$pac_MOD" -a -s "CONFTEST.$pac_MOD" ; then
testname="CONFTEST"
pac_cv_fc_module_case="upper"
else
# Clear because we must have gotten an error message
pac_MOD=""
fi
fi
if test -z "$pac_MOD" ; then
pac_cv_fc_module_ext="unknown"
else
pac_cv_fc_module_ext=$pac_MOD
fi
fi
],[
pac_cv_fc_module_ext="unknown"
])
AC_LANG_POP(Fortran)
])
dnl
dnl
dnl
AC_SUBST(FCMODEXT)
if test "$pac_cv_fc_module_ext" = "unknown" ; then
ifelse($2,,:,[$2])
else
ifelse($1,,FCMODEXT=$pac_MOD,[$1])
fi
])
dnl
dnl
dnl PAC_FC_MODULE_INCFLAG
AC_DEFUN([PAC_FC_MODULE_INCFLAG],[
AC_CACHE_CHECK([for Fortran 90 module include flag],
pac_cv_fc_module_incflag,[
AC_REQUIRE([PAC_FC_MODULE_EXT])
AC_LANG_PUSH(Fortran)
AC_LANG_CONFTEST([
AC_LANG_SOURCE([
module conf
integer n
parameter (n=1)
end module conf
])
])
pac_madedir="no"
if test ! -d conf ; then mkdir conftestdir ; pac_madedir="yes"; fi
if test "$pac_cv_fc_module_case" = "upper" ; then
pac_module="CONF.$pac_cv_fc_module_ext"
else
pac_module="conf.$pac_cv_fc_module_ext"
fi
AC_COMPILE_IFELSE([],[
if test -s "$pac_module" ; then
mv $pac_module conftestdir
# Remove any temporary files, and hide the work.pc file
# (if the compiler generates them)
if test -f work.pc ; then
mv -f work.pc conftest.pc
fi
rm -f work.pcl
else
AC_MSG_WARN([Unable to build a simple Fortran 90 module])
# echo "configure: failed program was:" >&AS_MESSAGE_LOG_FD
# cat conftest.$ac_ext >&AS_MESSAGE_LOG_FD
_AC_MSG_LOG_CONFTEST
fi
],
[]
)
# Remove the conftest* after AC_LANG_CONFTEST
rm -rf conftest.dSYM
rm -f conftest.$ac_ext
dnl Create the conftest here so the test isn't created everytime inside loop.
AC_LANG_CONFTEST([AC_LANG_PROGRAM([],[use conf])])
# Save the original FCFLAGS
saved_FCFLAGS="$FCFLAGS"
pac_cv_fc_module_incflag=""
for inchdr in '-I' '-M' '-p' ; do
FCFLAGS="$saved_FCFLAGS ${inchdr}conftestdir"
AC_COMPILE_IFELSE([],[pac_cv_fc_module_incflag="$inchdr" ; break])
done
if test "X$pac_cv_fc_module_incflag" = "X" ; then
if test -s conftest.pc ; then
mv conftest.pc conftestdir/mpimod.pc
echo "mpimod.pc" > conftestdir/mpimod.pcl
echo "`pwd`/conftestdir/mpimod.pc" >> conftestdir/mpimod.pcl
inchdr='-cl,'
FCFLAGS="$save_FCFLAGS ${inchdr}conftestdir"
AC_COMPILE_IFELSE([], [pac_fcompile_ok=yes], [pac_fcompile_ok=no])
if test "$pac_fcompile_ok" = "yes" ; then
pac_cv_fc_module_incflag="$inchdr"
# Not quite right; see the comments that follow
AC_MSG_RESULT([-cl,filename where filename contains a list of files and directories])
FC_WORK_FILES_ARG="-cl,mpimod.pcl"
FCMODINCSPEC="-cl,/mod.pcl"
else
# The version of the Intel compiler that I have refuses to let
# you put the "work catalog" list anywhere but the current directory.
pac_cv_fc_module_incflag="Unavailable!"
fi
else
# Early versions of the Intel ifc compiler required a *file*
# containing the names of files that contained the names of the
#
# -cl,filename.pcl
# filename.pcl contains
# fullpathname.pc
# The "fullpathname.pc" is generated, I believe, when a module is
# compiled.
# Intel compilers use a wierd system: -cl,filename.pcl . If no file is
# specified, work.pcl and work.pc are created. However, if you specify
# a file, it must contain a the name of a file ending in .pc . Ugh!
pac_cv_fc_module_incflag="unknown"
fi
fi
# Restore the original FCFLAGS
FCFLAGS="$saved_FCFLAGS"
if test "$pac_madedir" = "yes" ; then rm -rf conftestdir ; fi
# Remove the conftest* after AC_LANG_CONFTEST
# This is needed for Mac OSX 10.5
rm -rf conftest.dSYM
rm -f conftest*
AC_LANG_POP(Fortran)
])
AC_SUBST(FC_WORK_FILES_ARG)
AC_SUBST(FCMODINCFLAG)
FCMODINCFLAG=$pac_cv_fc_module_incflag
])
dnl
dnl
dnl
AC_DEFUN([PAC_FC_MODULE],[
PAC_FC_MODULE_EXT
PAC_FC_MODULE_INCFLAG
])
dnl
dnl PAC_FC_AND_F77_COMPATIBLE([action-if-true],[action-if-false])
dnl
dnl Determine whether object files compiled with Fortran 77 can be
dnl linked to Fortran 90 main programs.
dnl
dnl The test uses a name that includes an underscore unless the 3rd
dnl argument provides another routine name.
dnl
AC_DEFUN([PAC_FC_AND_F77_COMPATIBLE],[
AC_REQUIRE([PAC_PROG_FC_WORKS])
AC_CACHE_CHECK([whether Fortran 90 compiler works with Fortran 77 compiler],
pac_cv_fc_and_f77,[
pacTestRoutine=foo_abc
ifelse([$3],,,[eval pacTestRoutine=$3])
pac_cv_fc_and_f77="unknown"
# compile the f77 program and link with the f90 program
# The reverse may not work because the Fortran 90 environment may
# expect to be in control (and to provide library files unknown to any other
# environment, even Fortran 77!)
AC_LANG_PUSH(Fortran 77)
AC_COMPILE_IFELSE([
AC_LANG_SOURCE([
subroutine ${pacTestRoutine}(b)
integer b
b = b + 1
end
])
],[
# pac_f77compile_ok=yes
mv conftest.$OBJEXT pac_f77conftest.$OBJEXT
# Save original LIBS, prepend previously generated object file to LIBS
saved_LIBS="$LIBS"
LIBS="pac_f77conftest.$OBJEXT $LIBS"
AC_LANG_PUSH(Fortran)
AC_LINK_IFELSE([
AC_LANG_SOURCE([
program main
integer a
a = 1
call ${pacTestRoutine}(a)
end
])
],[pac_cv_fc_and_f77=yes],[pac_cv_fc_and_f77=no])
# Some versions of the Intel compiler produce these two files
rm -f work.pc work.pcl
# Restore LIBS
LIBS="$saved_LIBS"
AC_LANG_POP(Fortran)
# remove previously generated object file.
rm -f pac_f77conftest.$OBJEXT
], [
# pac_f77compile_ok=no
pac_cv_fc_and_f77=no
])
AC_LANG_POP(Fortran 77)
# Perform the requested action based on whether the test succeeded
if test "$pac_cv_fc_and_f77" = yes ; then
ifelse($1,,:,[$1])
else
ifelse($2,,:,[$2])
AC_MSG_WARN([See config.log for the failed test program and its output.])
fi
])
dnl
])
dnl
dnl
dnl /*D
dnl PAC_PROG_FC_HAS_POINTER - Determine if Fortran allows pointer type
dnl
dnl Synopsis:
dnl PAC_PROG_FC_HAS_POINTER(action-if-true,action-if-false)
dnl D*/
AC_DEFUN([PAC_PROG_FC_HAS_POINTER],[
AC_CACHE_CHECK([whether Fortran 90 has Cray-style pointer declaration],
pac_cv_prog_fc_has_pointer,[
AC_LANG_PUSH(Fortran)
AC_COMPILE_IFELSE([
AC_LANG_PROGRAM([],[
integer M
pointer (MPTR,M)
data MPTR/0/
])
],[
pac_cv_prog_fc_has_pointer="yes"
],[
pac_cv_prog_fc_has_pointer="no"
]) dnl Endof AC_COMPILE_IFELSE
AC_LANG_POP(Fortran)
])
if test "$pac_cv_prog_fc_has_pointer" = "yes" ; then
ifelse([$1],,:,[$1])
else
ifelse([$2],,:,[$2])
fi
])
dnl
dnl
dnl
AC_DEFUN([PAC_PROG_FC_AND_C_STDIO_LIBS],[
# To simply the code in the cache_check macro, chose the routine name
# first, in case we need it
confname=conf1_
case "$pac_cv_prog_f77_name_mangle" in
"lower underscore") confname=conf1_ ;;
"upper stdcall") confname=CONF1 ;;
upper) confname=CONF1 ;;
"lower doubleunderscore") confname=conf1_ ;;
lower) confname=conf1 ;;
"mixed underscore") confname=conf1_ ;;
mixed) confname=conf1 ;;
esac
AC_CACHE_CHECK([what libraries are needed to link Fortran90 programs with C routines that use stdio],pac_cv_prog_fc_and_c_stdio_libs,[
pac_cv_prog_fc_and_c_stdio_libs=unknown
AC_LANG_PUSH(C)
AC_COMPILE_IFELSE([
AC_LANG_SOURCE([
#include
int $confname( int a )
{ printf( "The answer is %d\n", a ); fflush(stdout); return 0; }
])
],[
pac_compile_ok=yes
mv conftest.$OBJEXT pac_conftest.$OBJEXT
# Save LIBS and prepend object file to LIBS
saved_LIBS="$LIBS"
LIBS="pac_conftest.$OBJEXT $LIBS"
AC_LANG_PUSH(Fortran)
AC_LINK_IFELSE([
AC_LANG_PROGRAM([],[call conf1(0)])
],[
pac_cv_prog_fc_and_c_stdio_libs=none
],[
# Try again with -lSystemStubs
LIBS="$LIBS -lSystemStubs"
AC_LINK_IFELSE([],[
pac_cv_prog_fc_and_c_stdio_libs="-lSystemStubs"
],[])
])
LIBS="$saved_LIBS"
AC_LANG_POP(Fortran)
rm -f pac_conftest.$OBJEXT
])
AC_LANG_POP(C)
dnl
if test "$pac_cv_prog_fc_and_c_stdio_libs" != none -a \
"$pac_cv_prog_fc_and_c_stdio_libs" != unknown ; then
FC_OTHER_LIBS="$FC_OTHER_LIBS $pac_cv_prog_fc_and_c_stdio_libs"
fi
])
dnl
])
dnl
dnl/*D
dnl PAC_FC_CHECK_COMPILER_OPTION - Check that a FC compiler option is
dnl accepted without warning messages
dnl
dnl Synopsis:
dnl PAC_FC_CHECK_COMPILER_OPTION(optionname,action-if-ok,action-if-fail)
dnl
dnl Output Effects:
dnl
dnl If no actions are specified, a working value is added to 'FCOPTIONS'
dnl
dnl Notes:
dnl This is now careful to check that the output is different, since
dnl some compilers are noisy.
dnl
dnl We are extra careful to prototype the functions in case compiler options
dnl that complain about poor code are in effect.
dnl
dnl Because this is a long script, we have ensured that you can pass a
dnl variable containing the option name as the first argument.
dnl D*/
AC_DEFUN([PAC_FC_CHECK_COMPILER_OPTION],[
AC_MSG_CHECKING([whether Fortran 90 compiler accepts option $1])
pac_opt="$1"
AC_LANG_PUSH(Fortran)
dnl Instead of defining our own ac_link and ac_compile and do AC_TRY_EVAL
dnl on these variables. We modify ac_link and ac_compile used by AC_*_IFELSE
dnl by piping the output of the command to a logfile. The reason is that
dnl 1) AC_TRY_EVAL is discouraged by Autoconf. 2) defining our ac_link and
dnl ac_compile could mess up the usage and order of FCFLAGS, LDFLAGS
dnl and LIBS in these commands, i.e. deviate from how GNU standard uses
dnl these variables.
dnl
dnl Replace " >&AS_MESSAGE_LOG_FD" by "> file 2>&1" in ac_link and ac_compile
pac_link="`echo $ac_link | sed -e 's|>.*$|> $pac_logfile 2>\&1|g'`"
dnl echo "ac_link=\"$ac_link\""
dnl echo "pac_link=\"$pac_link\""
saved_ac_link="$ac_link"
ac_link="$pac_link"
dnl echo "ac_link=\"$ac_link\""
pac_compile="`echo $ac_compile | sed -e 's|>.*$|> $pac_logfile 2>\&1|g'`"
dnl echo "ac_compile=\"$ac_compile\""
dnl echo "pac_compile=\"$pac_compile\""
saved_ac_compile="$ac_compile"
ac_compile="$pac_compile"
dnl echo "ac_compile=\"$ac_compile\""
FCFLAGS_orig="$FCFLAGS"
FCFLAGS_opt="$pac_opt $FCFLAGS"
pac_result="unknown"
AC_LANG_CONFTEST([AC_LANG_PROGRAM()])
FCFLAGS="$FCFLAGS_orig"
pac_logfile="pac_test1.log"
rm -f $pac_logfile
AC_LINK_IFELSE([], [
FCFLAGS="$FCFLAGS_opt"
pac_logfile="pac_test2.log"
rm -f $pac_logfile
AC_LINK_IFELSE([], [
PAC_RUNLOG_IFELSE([diff -b pac_test1.log pac_test2.log],
[pac_result=yes], [pac_result=no])
],[
pac_result=no
])
], [
pac_result=no
])
AC_MSG_RESULT([$pac_result])
dnl Delete the conftest created by AC_LANG_CONFTEST.
rm -f conftest.$ac_ext
#
if test "$pac_result" = "yes" ; then
AC_MSG_CHECKING([whether routines compiled with $pac_opt can be linked with ones compiled without $pac_opt])
pac_result=unknown
FCFLAGS="$FCFLAGS_orig"
pac_logfile="pac_test3.log"
rm -f $pac_logfile
AC_COMPILE_IFELSE([
AC_LANG_SOURCE([
subroutine try()
end
])
],[
mv conftest.$OBJEXT pac_conftest.$OBJEXT
saved_LIBS="$LIBS"
LIBS="pac_conftest.$OBJEXT $LIBS"
FCFLAGS="$FCFLAGS_opt"
pac_logfile="pac_test4.log"
rm -f $pac_logfile
AC_LINK_IFELSE([AC_LANG_PROGRAM()], [
diffcmd='diff -b pac_test3.log pac_test4.log'
PAC_RUNLOG_IFELSE([diff -b pac_test2.log pac_test4.log],
[pac_result=yes], [pac_result=no])
],[
pac_result=no
])
LIBS="$saved_LIBS"
rm -f pac_conftest.$OBJEXT
],[
pac_result=no
])
AC_MSG_RESULT([$pac_result])
rm -f pac_test3.log pac_test4.log
fi
rm -f pac_test1.log pac_test2.log
dnl Restore everything in AC that has been overwritten
ac_link="$saved_ac_link"
ac_compile="$saved_ac_compile"
dnl echo "ac_link=\"$ac_link\""
dnl echo "ac_compile=\"$ac_compile\""
dnl Restore FCFLAGS before 2nd/3rd argument commands are executed,
dnl as 2nd/3rd argument command could be modifying FCFLAGS.
FCFLAGS="$FCFLAGS_orig"
if test "$pac_result" = "yes" ; then
ifelse([$2],[],[FCOPTIONS="$FCOPTIONS $1"],[$2])
else
ifelse([$3],[],[:],[$3])
fi
# This is needed for Mac OSX 10.5
rm -rf conftest.dSYM
rm -f conftest*
AC_LANG_POP(Fortran)
])
dnl /*D
dnl PAC_FC_WORKS_WITH_CPP
dnl
dnl Checks if Fortran 90 compiler works with C preprocessor
dnl
dnl Most systems allow the Fortran compiler to process .F and .F90 files
dnl using the C preprocessor. However, some systems either do not
dnl allow this or have serious bugs (OSF Fortran compilers have a bug
dnl that generates an error message from cpp). The following test
dnl checks to see if .F works, and if not, whether "cpp -P -C" can be used
dnl D*/
AC_DEFUN([PAC_FC_WORKS_WITH_CPP],[
AC_REQUIRE([AC_PROG_CPP])
AC_MSG_CHECKING([whether Fortran 90 compiler processes .F90 files with C preprocessor])
AC_LANG_PUSH([Fortran])
saved_fc_ext=${ac_ext}
ac_ext="F90"
saved_FCFLAGS="$FCFLAGS"
FCFLAGS="$FCFLAGS $CPPFLAGS"
AC_LANG_CONFTEST([
AC_LANG_SOURCE([
program main
#define ASIZE 10
integer a(ASIZE)
end
])
])
AC_COMPILE_IFELSE([],[
pac_cv_fc_accepts_F90=yes
ifelse([$1],[],[],[$1=""])
],[
pac_cv_fc_accepts_F90=no
ifelse([$1],[],[:],[$1="false"])
])
# Restore Fortran's ac_ext but not FCFLAGS
ac_ext="$saved_fc_ext"
if test "$pac_cv_fc_accepts_F90" != "yes" ; then
pac_cpp_fc="$ac_cpp -C -P conftest.F90 > conftest.$ac_ext"
PAC_RUNLOG_IFELSE([$pac_cpp_fc],[
if test -s conftest.${ac_ext} ; then
AC_COMPILE_IFELSE([],[
pac_cv_fc_accepts_F90="no, use cpp"
ifelse([$1],[],[],[$1="$CPP -C -P"])
],[])
rm -f conftest.${ac_ext}
fi
],[])
fi
FCFLAGS="$saved_FCFLAGS"
rm -f conftest.F90
AC_LANG_POP([Fortran])
AC_MSG_RESULT([$pac_cv_fc_accepts_F90])
])
dnl
dnl PAC_FC_VENDOR:
dnl Try to get a version string for the F90 compiler. We may
dnl need this to find likely command-line arguments for accessing
dnl shared libraries
dnl
AC_DEFUN([PAC_FC_VENDOR],[
AC_MSG_CHECKING([for Fortran 90 compiler vendor])
# This is complicated by some compilers (such as the Intel 8.1 ifort)
# that return a non-zero status even when they accept the -V option
# (a zero status is returned only if there is a file).
pac_cv_fc_vendor="unknown"
for arg in --version -V -v ; do
rm -f conftest.txt
PAC_RUNLOG([$FC $arg conftest.txt 2>&1])
# Ignore the return code, because some compilers set the
# return code to zero on invalid arguments and some to
# non-zero on success (with no files to compile)
if test -f conftest.txt ; then
if grep 'Portland Group' conftest.txt >/dev/null 2>&1 ; then
pac_cv_fc_vendor=pgi
elif grep 'Sun Workshop' conftest.txt >/dev/null 2>&1 ; then
pac_cv_fc_vendor=sun
elif grep 'Sun Fortran 9' conftest.txt >/dev/null 2>&1 ; then
pac_cv_fc_vendor=sun
elif grep 'Absoft' conftest.txt >/dev/null 2>&1 ; then
pac_cv_fc_vendor=absoft
elif grep 'G95' conftest.txt >/dev/null 2>&1 ; then
pac_cv_fc_vendor=gnu
elif grep 'GNU Fortran' conftest.txt >/dev/null 2>&1 ; then
# This is gfortran
pac_cv_fc_vendor=gnu
elif grep Intel conftest.txt >/dev/null 2>&1 ; then
pac_cv_fc_vendor=intel
fi
fi
if test "$pac_cv_fc_vendor" != "unknown" ; then break ; fi
done
if test "$pac_cv_fc_vendor" = "unknown" ; then
# Try to use the compiler name
if test "$FC" = "ifort" -o "$FC" = "ifc" ; then
pac_cv_fc_vendor=intel
elif test "$FC" = "pgf90" ; then
pac_cv_fc_vendor=pgi
elif test "$FC" = "xlf90" -o "$FC" = "xlf90_r" ; then
pac_cv_fc_vendor=ibm
elif test "$FC" = "xlf95" -o "$FC" = "xlf95_r" ; then
pac_cv_fc_vendor=ibm
fi
fi
AC_MSG_RESULT([$pac_cv_fc_vendor])
rm -f conftest.txt
# End of checking for F90 compiler vendor
])
dnl
dnl PAC_F77_IS_FC([ACTION_IF_TRUE],[ACTION_IF_FALSE])
dnl Check if F77 is a Fortran 90 compiler.
dnl
AC_DEFUN([PAC_F77_IS_FC],[
AC_MSG_CHECKING([whether $F77 is a Fortran 90 compiler])
AC_LANG_PUSH([Fortran 77])
saved_ac_ext=$ac_ext
ac_ext="f90"
AC_LINK_IFELSE([
AC_LANG_SOURCE([
program main
integer, dimension(10) :: n
integer k
print *, range(k)
end
])
],[
pac_cv_prog_f77_is_fc=yes
ifelse([$1],[],[],[$1])
],[
pac_cv_prog_f77_is_fc=no
ifelse([$2],[],[],[$2])
])
AC_MSG_RESULT([$pac_cv_prog_f77_is_fc])
AC_LANG_POP([Fortran 77])
])
dnl
dnl PAC_FC_FLOAT_MODEL(float_type, [variable-set-if-successful-test])
dnl variable-set-if-successful-test is optional variable.
dnl
dnl This is a runtime test.
dnl
AC_DEFUN([PAC_FC_FLOAT_MODEL],[
type="$1"
AC_MSG_CHECKING([for precision and range of $type])
AC_LANG_PUSH([Fortran])
AC_LINK_IFELSE([
AC_LANG_SOURCE([
program main
$type aa
print *, precision(aa), ",", range(aa)
end
])
],[
rm -f pac_conftest.out
PAC_RUNLOG([./conftest$EXEEXT > pac_conftest.out])
if test -s pac_conftest.out ; then
pac_fc_num_model="`cat pac_conftest.out | sed -e 's/ */ /g'`"
AC_MSG_RESULT([$pac_fc_num_model])
ifelse([$2],[],[],[$2=$pac_fc_num_model])
else
AC_MSG_WARN([No output from test program!])
fi
rm -f pac_conftest.out
],[
AC_MSG_WARN([Failed to build program to determine the precision and range of $type])
])
AC_LANG_POP([Fortran])
])
dnl
dnl PAC_FC_SIMPLE_NUMBER_MODEL(message,test-fc-code,
dnl [variable-set-if-successful-test])
dnl message : message of what test-fc-code is checking
dnl test-fc-code : Fortran 90 code to check a float or integer type's data model
dnl variable-set-if-successful-test :
dnl The optional variable to be set if the test-fc-code
dnl is successful in returning the simple data model.
dnl
dnl This is a runtime test.
dnl
AC_DEFUN([PAC_FC_SIMPLE_NUMBER_MODEL],[
pac_msg="$1"
AC_MSG_CHECKING([for $pac_msg])
AC_LANG_PUSH([Fortran])
AC_LINK_IFELSE([
AC_LANG_PROGRAM([],[
$2
])
],[
rm -f pac_conftest.out
PAC_RUNLOG([./conftest$EXEEXT > pac_conftest.out])
if test -s pac_conftest.out ; then
pac_fc_num_model="`cat pac_conftest.out | sed -e 's/ */ /g'`"
AC_MSG_RESULT([$pac_fc_num_model])
ifelse([$3],[],[],[$3=$pac_fc_num_model])
else
AC_MSG_WARN([No output from test program!])
fi
rm -f pac_conftest.out
],[
AC_MSG_WARN([Failed to build program to determine $pac_msg])
])
AC_LANG_POP([Fortran])
])
dnl
dnl PAC_FC_AVAIL_INTEGER_MODELS([INTEGER-MODELS-FLAG])
dnl Both INTEGER-MODELS-FLAG is an optional variable to be set if provided.
dnl If it isn't provided, PAC_FC_ALL_INTEGER_MODELS will be set.
dnl
dnl This is a runtime test.
dnl
AC_DEFUN([PAC_FC_AVAIL_INTEGER_MODELS],[
AC_MSG_CHECKING([for available integer kinds])
AC_LANG_PUSH([Fortran])
AC_LINK_IFELSE([
AC_LANG_SOURCE([
program main
integer r, lastkind
lastkind=selected_int_kind(1)
do r=2,30
k = selected_int_kind(r)
if (k .ne. lastkind) then
print *, r-1,",",lastkind
lastkind = k
endif
if (k .le. 0) then
exit
endif
enddo
if (k.ne.lastkind) then
print *, 31, ",", k
endif
end
])
],[
rm -f pac_conftest.out
PAC_RUNLOG([./conftest$EXEEXT > pac_conftest.out])
if test -s pac_conftest.out ; then
pac_flag=`cat pac_conftest.out | sed -e 's/ */ /g'| tr '\012' ','`
AC_MSG_RESULT([$pac_flag])
pac_validKinds="`sed -e 's/ */ /g' pac_conftest.out | tr '\012' ':'`"
ifelse([$1],[],[PAC_FC_ALL_INTEGER_MODELS=$pac_flag],[$1=$pac_flag])
else
AC_MSG_WARN([No output from test program!])
fi
rm -f pac_conftest.out
],[
AC_MSG_WARN([Failed to build program to determine available integer models])
])
AC_LANG_POP([Fortran])
])
dnl
dnl PAC_FC_INTEGER_MODEL_MAP([INTEGER-MODEL-MAP-FLAG])
dnl Both INTEGER-MODEL-MAP-FLAG is an optional variable to be set if provided.
dnl If it isn't provided, PAC_FC_INTEGER_MODEL_MAP will be set.
dnl
dnl This test expect pac_validKinds set by PAC_FC_ALL_INTEGER_MODELS.
dnl
dnl This is a runtime test.
dnl
dnl Compile the C subroutine as pac_conftest.o and Link it with a Fortran main.
AC_DEFUN([PAC_FC_INTEGER_MODEL_MAP],[
AC_REQUIRE([PAC_FC_AVAIL_INTEGER_MODELS])
AC_MSG_CHECKING([for available integer ranges])
AC_LANG_PUSH([C])
AC_COMPILE_IFELSE([
AC_LANG_SOURCE([
#include
#include "confdefs.h"
#ifdef F77_NAME_UPPER
#define cisize_ CISIZE
#define isize_ ISIZE
#elif defined(F77_NAME_LOWER) || defined(F77_NAME_MIXED)
#define cisize_ cisize
#define isize_ isize
#endif
int cisize_(char *,char*);
int cisize_(char *i1p, char *i2p)
{
int isize_val=0;
isize_val = (int)(i2p - i1p);
return isize_val;
}
])
],[
PAC_RUNLOG([mv conftest.$OBJEXT pac_conftest.$OBJEXT])
pac_ccompile_ok=yes
],[
pac_ccompile_ok=no
])
AC_LANG_POP([C])
dnl
if test "$pac_ccompile_ok" = "yes" ; then
saved_LIBS="$LIBS"
LIBS="pac_conftest.$OBJEXT $LIBS"
saved_IFS=$IFS
IFS=:
AC_LANG_PUSH([Fortran])
pac_flag=""
for rangekind in $pac_validKinds ; do
kind="`echo $rangekind | sed -e 's/.*,//'`"
range="`echo $rangekind | sed -e 's/,.*//'`"
AC_LANG_CONFTEST([
AC_LANG_SOURCE([
program main
integer (kind=$kind) a(2)
integer cisize
print *, $range, ",", $kind, ",", cisize( a(1), a(2) )
end
])
])
IFS=$saved_IFS
AC_LINK_IFELSE([],[
rm -f pac_conftest.out
PAC_RUNLOG([./conftest$EXEEXT > pac_conftest.out])
if test -s pac_conftest.out ; then
sizes="`cat pac_conftest.out | sed -e 's/ */ /g'`"
pac_flag="$pac_flag { $sizes },"
else
AC_MSG_WARN([No output from test program!])
fi
rm -f pac_conftest.out
],[
AC_MSG_WARN([Fortran program fails to build!])
])
IFS=:
done
IFS=$saved_IFS
AC_MSG_RESULT([$pac_flag])
ifelse([$1],[],[PAC_FC_INTEGER_MODEL_MAP=$pac_flag],[$1=$pac_flag])
AC_LANG_POP([Fortran])
LIBS="$saved_LIBS"
rm -f pac_conftest.$OBJEXT
fi
])
armci-mpi/m4/aclocal_cc.m4 0000644 0001750 0001750 00000143521 12662706250 015045 0 ustar mbanck mbanck dnl AC_PROG_CC_GNU
ifdef([AC_PROG_CC_GNU],,[AC_DEFUN([AC_PROG_CC_GNU],)])
dnl PAC_PROG_CC - reprioritize the C compiler search order
AC_DEFUN([PAC_PROG_CC],[
PAC_PUSH_FLAG([CFLAGS])
AC_PROG_CC([gcc icc pgcc xlc xlC pathcc cc])
PAC_POP_FLAG([CFLAGS])
])
dnl
dnl/*D
dnl PAC_C_CHECK_COMPILER_OPTION - Check that a compiler option is accepted
dnl without warning messages
dnl
dnl Synopsis:
dnl PAC_C_CHECK_COMPILER_OPTION(optionname,action-if-ok,action-if-fail)
dnl
dnl Output Effects:
dnl
dnl If no actions are specified, a working value is added to 'COPTIONS'
dnl
dnl Notes:
dnl This is now careful to check that the output is different, since
dnl some compilers are noisy.
dnl
dnl We are extra careful to prototype the functions in case compiler options
dnl that complain about poor code are in effect.
dnl
dnl Because this is a long script, we have ensured that you can pass a
dnl variable containing the option name as the first argument.
dnl
dnl gcc 4.2.4 on 32-bit does not complain about the -Wno-type-limits option
dnl even though it doesn't support it. However, when another warning is
dnl triggered, it gives an error that the option is not recognized. So we
dnl need to test with a conftest file that will generate warnings
dnl D*/
AC_DEFUN([PAC_C_CHECK_COMPILER_OPTION],[
AC_MSG_CHECKING([whether C compiler accepts option $1])
pccco_save_CFLAGS="$CFLAGS"
CFLAGS="$1 $CFLAGS"
rm -f conftest.out
pac_success=no
# conftest3.c has an invalid prototype to ensure we generate warnings
echo 'int main(){}' > conftest3.c
echo 'int foo(void);int foo(void){return 0;}' > conftest2.c
echo 'int main(void);int main(void){return 0;}' > conftest.c
if ${CC-cc} $CFLAGS $CPPFLAGS -o conftest conftest3.c $LDFLAGS >/dev/null 2>&1 &&
${CC-cc} $pccco_save_CFLAGS $CPPFLAGS -o conftest conftest.c $LDFLAGS >conftest.bas 2>&1 ; then
if ${CC-cc} $CFLAGS $CPPFLAGS -o conftest conftest.c $LDFLAGS >conftest.out 2>&1 ; then
if diff -b conftest.out conftest.bas >/dev/null 2>&1 ; then
AC_MSG_RESULT(yes)
AC_MSG_CHECKING([whether routines compiled with $1 can be linked with ones compiled without $1])
rm -f conftest.out
rm -f conftest.bas
if ${CC-cc} -c $pccco_save_CFLAGS $CPPFLAGS conftest2.c >conftest2.out 2>&1 ; then
if ${CC-cc} $CFLAGS $CPPFLAGS -o conftest conftest2.o conftest.c $LDFLAGS >conftest.bas 2>&1 ; then
if ${CC-cc} $CFLAGS $CPPFLAGS -o conftest conftest2.o conftest.c $LDFLAGS >conftest.out 2>&1 ; then
if diff -b conftest.out conftest.bas >/dev/null 2>&1 ; then
pac_success=yes
else
:
fi
else
:
fi
else
# Could not link with the option!
:
fi
else
if test -s conftest2.out ; then
cat conftest2.out >&AC_FD_CC
fi
fi
else
:
fi
else
:
fi
else
# Could not compile without the option!
:
fi
CFLAGS="$pccco_save_CFLAGS"
if test "$pac_success" = yes ; then
AC_MSG_RESULT(yes)
ifelse($2,,COPTIONS="$COPTIONS $1",$2)
else
AC_MSG_RESULT(no)
if test -s conftest.out ; then cat conftest.out >&AC_FD_CC ; fi
$3
fi
# This is needed for Mac OSX 10.5
rm -rf conftest.dSYM
rm -f conftest*
])
dnl
dnl/*D
dnl PAC_C_OPTIMIZATION - Determine C options for producing optimized code
dnl
dnl Synopsis
dnl PAC_C_OPTIMIZATION([action if found])
dnl
dnl Output Effect:
dnl Adds options to 'COPTIONS' if no other action is specified
dnl
dnl Notes:
dnl This is a temporary standin for compiler optimization.
dnl It should try to match known systems to known compilers (checking, of
dnl course), and then falling back to some common defaults.
dnl Note that many compilers will complain about -g and aggressive
dnl optimization.
dnl D*/
AC_DEFUN([PAC_C_OPTIMIZATION],[
for copt in "-O4 -Ofast" "-Ofast" "-fast" "-O3" "-xO3" "-O" ; do
PAC_C_CHECK_COMPILER_OPTION($copt,found_opt=yes,found_opt=no)
if test "$found_opt" = "yes" ; then
ifelse($1,,COPTIONS="$COPTIONS $copt",$1)
break
fi
done
if test "$ac_cv_prog_gcc" = "yes" ; then
for copt in "-fomit-frame-pointer" "-finline-functions" \
"-funroll-loops" ; do
PAC_C_CHECK_COMPILER_OPTION($copt,found_opt=yes,found_opt=no)
if test "$found_opt" = "yes" ; then
ifelse($1,,COPTIONS="$COPTIONS $copt",$1)
# no break because we're trying to add them all
fi
done
# We could also look for architecture-specific gcc options
fi
])
dnl/*D
dnl PAC_PROG_C_UNALIGNED_DOUBLES - Check that the C compiler allows unaligned
dnl doubles
dnl
dnl Synopsis:
dnl PAC_PROG_C_UNALIGNED_DOUBLES(action-if-true,action-if-false,
dnl action-if-unknown)
dnl
dnl Notes:
dnl 'action-if-unknown' is used in the case of cross-compilation.
dnl D*/
AC_DEFUN([PAC_PROG_C_UNALIGNED_DOUBLES],[
AC_CACHE_CHECK([whether C compiler allows unaligned doubles],
pac_cv_prog_c_unaligned_doubles,[
AC_TRY_RUN([
void fetch_double( v )
double *v;
{
*v = 1.0;
}
int main( argc, argv )
int argc;
char **argv;
{
int p[4];
double *p_val;
fetch_double( (double *)&(p[0]) );
p_val = (double *)&(p[0]);
if (*p_val != 1.0) return 1;
fetch_double( (double *)&(p[1]) );
p_val = (double *)&(p[1]);
if (*p_val != 1.0) return 1;
return 0;
}
],pac_cv_prog_c_unaligned_doubles="yes",pac_cv_prog_c_unaligned_doubles="no",
pac_cv_prog_c_unaligned_doubles="unknown")])
ifelse($1,,,if test "X$pac_cv_prog_c_unaligned_doubles" = "yes" ; then
$1
fi)
ifelse($2,,,if test "X$pac_cv_prog_c_unaligned_doubles" = "no" ; then
$2
fi)
ifelse($3,,,if test "X$pac_cv_prog_c_unaligned_doubles" = "unknown" ; then
$3
fi)
])
dnl/*D
dnl PAC_PROG_C_WEAK_SYMBOLS - Test whether C supports weak alias symbols.
dnl
dnl Synopsis
dnl PAC_PROG_C_WEAK_SYMBOLS(action-if-true,action-if-false)
dnl
dnl Output Effect:
dnl Defines one of the following if a weak symbol pragma is found:
dnl.vb
dnl HAVE_PRAGMA_WEAK - #pragma weak
dnl HAVE_PRAGMA_HP_SEC_DEF - #pragma _HP_SECONDARY_DEF
dnl HAVE_PRAGMA_CRI_DUP - #pragma _CRI duplicate x as y
dnl.ve
dnl May also define
dnl.vb
dnl HAVE_WEAK_ATTRIBUTE
dnl.ve
dnl if functions can be declared as 'int foo(...) __attribute__ ((weak));'
dnl sets the shell variable pac_cv_attr_weak to yes.
dnl Also checks for __attribute__((weak_import)) which is supported by
dnl Apple in Mac OSX (at least in Darwin). Note that this provides only
dnl weak symbols, not weak aliases
dnl
dnl D*/
AC_DEFUN([PAC_PROG_C_WEAK_SYMBOLS],[
pragma_extra_message=""
AC_CACHE_CHECK([for type of weak symbol alias support],
pac_cv_prog_c_weak_symbols,[
# Test for weak symbol support...
# We can't put # in the message because it causes autoconf to generate
# incorrect code
AC_TRY_LINK([
extern int PFoo(int);
#pragma weak PFoo = Foo
int Foo(int a) { return a; }
],[return PFoo(1);],has_pragma_weak=yes)
#
# Some systems (Linux ia64 and ecc, for example), support weak symbols
# only within a single object file! This tests that case.
# Note that there is an extern int PFoo declaration before the
# pragma. Some compilers require this in order to make the weak symbol
# extenally visible.
if test "$has_pragma_weak" = yes ; then
# This is needed for Mac OSX 10.5
rm -rf conftest.dSYM
rm -f conftest*
cat >>conftest1.c <>conftest2.c <>conftest1.c <>conftest2.c <> config.log
echo "Failed program was" >> config.log
cat conftest1.c >>config.log
cat conftest2.c >>config.log
if test -s conftest.out ; then cat conftest.out >> config.log ; fi
has_pragma_weak=0
pragma_extra_message="pragma weak accepted but does not work (probably creates two non-weak entries)"
fi
else
echo "$ac_link2" >>config.log
echo "Failed program was" >>config.log
cat conftest1.c >>config.log
cat conftest2.c >>config.log
if test -s conftest.out ; then cat conftest.out >> config.log ; fi
has_pragma_weak=0
pragma_extra_message="pragma weak does not work outside of a file"
fi
# This is needed for Mac OSX 10.5
rm -rf conftest.dSYM
rm -f conftest*
fi
dnl
if test -z "$pac_cv_prog_c_weak_symbols" ; then
AC_TRY_LINK([
extern int PFoo(int);
#pragma _HP_SECONDARY_DEF Foo PFoo
int Foo(int a) { return a; }
],[return PFoo(1);],pac_cv_prog_c_weak_symbols="pragma _HP_SECONDARY_DEF")
fi
dnl
if test -z "$pac_cv_prog_c_weak_symbols" ; then
AC_TRY_LINK([
extern int PFoo(int);
#pragma _CRI duplicate PFoo as Foo
int Foo(int a) { return a; }
],[return PFoo(1);],pac_cv_prog_c_weak_symbols="pragma _CRI duplicate x as y")
fi
dnl
if test -z "$pac_cv_prog_c_weak_symbols" ; then
pac_cv_prog_c_weak_symbols="no"
fi
dnl
dnl If there is an extra explanatory message, echo it now so that it
dnl doesn't interfere with the cache result value
if test -n "$pragma_extra_message" ; then
echo $pragma_extra_message
fi
dnl
])
if test "$pac_cv_prog_c_weak_symbols" = "no" ; then
ifelse([$2],,:,[$2])
else
case "$pac_cv_prog_c_weak_symbols" in
"pragma weak") AC_DEFINE(HAVE_PRAGMA_WEAK,1,[Supports weak pragma])
;;
"pragma _HP") AC_DEFINE(HAVE_PRAGMA_HP_SEC_DEF,1,[HP style weak pragma])
;;
"pragma _CRI") AC_DEFINE(HAVE_PRAGMA_CRI_DUP,1,[Cray style weak pragma])
;;
esac
ifelse([$1],,:,[$1])
fi
AC_CACHE_CHECK([whether __attribute__ ((weak)) allowed],
pac_cv_attr_weak,[
AC_TRY_COMPILE([int foo(int) __attribute__ ((weak));],[int a;],
pac_cv_attr_weak=yes,pac_cv_attr_weak=no)])
# Note that being able to compile with weak_import doesn't mean that
# it works.
AC_CACHE_CHECK([whether __attribute__ ((weak_import)) allowed],
pac_cv_attr_weak_import,[
AC_TRY_COMPILE([int foo(int) __attribute__ ((weak_import));],[int a;],
pac_cv_attr_weak_import=yes,pac_cv_attr_weak_import=no)])
# Check if the alias option for weak attributes is allowed
AC_CACHE_CHECK([whether __attribute__((weak,alias(...))) allowed],
pac_cv_attr_weak_alias,[
AC_TRY_COMPILE([int foo(int) __attribute__((weak,alias("__foo")));],[int a;],
pac_cv_attr_weak_alias=yes,pac_cv_attr_weak_alias=no)])
])
#
# This is a replacement that checks that FAILURES are signaled as well
# (later configure macros look for the .o file, not just success from the
# compiler, but they should not HAVE to
#
dnl --- insert 2.52 compatibility here ---
dnl 2.52 does not have AC_PROG_CC_WORKS
ifdef([AC_PROG_CC_WORKS],,[AC_DEFUN([AC_PROG_CC_WORKS],)])
dnl
AC_DEFUN([PAC_PROG_CC_WORKS],
[AC_PROG_CC_WORKS
AC_MSG_CHECKING([whether the C compiler sets its return status correctly])
AC_LANG_SAVE
AC_LANG_C
AC_TRY_COMPILE(,[int a = bzzzt;],notbroken=no,notbroken=yes)
AC_MSG_RESULT($notbroken)
if test "$notbroken" = "no" ; then
AC_MSG_ERROR([installation or configuration problem: C compiler does not
correctly set error code when a fatal error occurs])
fi
])
dnl/*D
dnl PAC_PROG_C_MULTIPLE_WEAK_SYMBOLS - Test whether C and the
dnl linker allow multiple weak symbols.
dnl
dnl Synopsis
dnl PAC_PROG_C_MULTIPLE_WEAK_SYMBOLS(action-if-true,action-if-false)
dnl
dnl
dnl D*/
AC_DEFUN([PAC_PROG_C_MULTIPLE_WEAK_SYMBOLS],[
AC_CACHE_CHECK([for multiple weak symbol support],
pac_cv_prog_c_multiple_weak_symbols,[
# Test for multiple weak symbol support...
#
# This is needed for Mac OSX 10.5
rm -rf conftest.dSYM
rm -f conftest*
cat >>conftest1.c <>conftest2.c <>config.log
echo "Failed program was" >>config.log
cat conftest1.c >>config.log
cat conftest2.c >>config.log
if test -s conftest.out ; then cat conftest.out >> config.log ; fi
fi
# This is needed for Mac OSX 10.5
rm -rf conftest.dSYM
rm -f conftest*
dnl
])
if test "$pac_cv_prog_c_multiple_weak_symbols" = "yes" ; then
ifelse([$1],,:,[$1])
else
ifelse([$2],,:,[$2])
fi
])
dnl Use the value of enable-strict to update CFLAGS
dnl pac_cc_strict_flags contains the strict flags.
dnl
dnl -std=c89 is used to select the C89 version of the ANSI/ISO C standard.
dnl As of this writing, many C compilers still accepted only this version,
dnl not the later C99 version. When all compilers accept C99, this
dnl should be changed to the appropriate standard level. Note that we've
dnl had trouble with gcc 2.95.3 accepting -std=c89 but then trying to
dnl compile program with a invalid set of options
dnl (-D __STRICT_ANSI__-trigraphs)
AC_DEFUN([PAC_CC_STRICT],[
export enable_strict_done
if test "$enable_strict_done" != "yes" ; then
# Some comments on strict warning options.
# These were added to reduce warnings:
# -Wno-missing-field-initializers -- We want to allow a struct to be
# initialized to zero using "struct x y = {0};" and not require
# each field to be initialized individually.
# -Wno-unused-parameter -- For portability, some parameters go unused
# when we have different implementations of functions for
# different platforms
# -Wno-unused-label -- We add fn_exit: and fn_fail: on all functions,
# but fn_fail may not be used if the function doesn't return an
# error.
# -Wno-sign-compare -- read() and write() return bytes read/written
# as a signed value, but we often compare this to size_t (or
# msg_sz_t) variables.
# -Wno-format-zero-length -- this warning is irritating and useless, since
# a zero-length format string is very well defined
# -Wno-type-limits -- There are places where we compare an unsigned to
# a constant that happens to be zero e.g., if x is unsigned and
# MIN_VAL is zero, we'd like to do "MPIU_Assert(x >= MIN_VAL);".
# Note this option is not supported by gcc 4.2. This needs to be added
# after most other warning flags, so that we catch a gcc bug on 32-bit
# that doesn't give a warning that this is unsupported, unless another
# warning is triggered, and then if gives an error.
# These were removed to reduce warnings:
# -Wcast-qual -- Sometimes we need to cast "volatile char*" to
# "char*", e.g., for memcpy.
# -Wpadded -- We catch struct padding with asserts when we need to
# -Wredundant-decls -- Having redundant declarations is benign and the
# code already has some.
# -Waggregate-return -- This seems to be a performance-related warning
# aggregate return values are legal in ANSI C, but they may be returned
# in memory rather than through a register. We do use aggregate return
# values, but they are structs of a single basic type (used to enforce
# type checking for relative vs. absolute ptrs), and with optimization
# the aggregate value is converted to a scalar.
# the embedded newlines in this string are safe because we evaluate each
# argument in the for-loop below and append them to the CFLAGS with a space
# as the separator instead
pac_common_strict_flags="
-Wall
-Wextra
-Wno-missing-field-initializers
-Wstrict-prototypes
-Wmissing-prototypes
-DGCC_WALL
-Wno-unused-parameter
-Wno-unused-label
-Wshadow
-Wmissing-declarations
-Wno-long-long
-Wfloat-equal
-Wdeclaration-after-statement
-Wundef
-Wno-endif-labels
-Wpointer-arith
-Wbad-function-cast
-Wcast-align
-Wwrite-strings
-Wno-sign-compare
-Wold-style-definition
-Wno-multichar
-Wno-deprecated-declarations
-Wpacked
-Wnested-externs
-Winvalid-pch
-Wno-pointer-sign
-Wvariadic-macros
-Wno-format-zero-length
-Wno-type-limits
"
enable_c89=yes
enable_c99=no
enable_posix=yes
enable_opt=yes
flags="`echo $1 | sed -e 's/:/ /g' -e 's/,/ /g'`"
for flag in ${flags}; do
case "$flag" in
c89)
enable_strict_done="yes"
enable_c89=yes
;;
c99)
enable_strict_done="yes"
enable_c99=yes
;;
posix)
enable_strict_done="yes"
enable_posix=yes
;;
noposix)
enable_strict_done="yes"
enable_posix=no
;;
opt)
enable_strict_done="yes"
enable_opt=yes
;;
noopt)
enable_strict_done="yes"
enable_opt=no
;;
all|yes)
enable_strict_done="yes"
enable_c89=yes
enable_posix=yes
enable_opt=yes
;;
no)
# Accept and ignore this value
:
;;
*)
if test -n "$flag" ; then
AC_MSG_WARN([Unrecognized value for enable-strict:$flag])
fi
;;
esac
done
pac_cc_strict_flags=""
if test "${enable_strict_done}" = "yes" ; then
if test "${enable_opt}" = "yes" ; then
pac_cc_strict_flags="-O2"
fi
pac_cc_strict_flags="$pac_cc_strict_flags $pac_common_strict_flags"
if test "${enable_posix}" = "yes" ; then
PAC_APPEND_FLAG([-D_POSIX_C_SOURCE=199506L],[pac_cc_strict_flags])
fi
# We only allow one of strict-C99 or strict-C89 to be
# enabled. If C99 is enabled, we automatically disable C89.
if test "${enable_c99}" = "yes" ; then
PAC_APPEND_FLAG([-std=c99],[pac_cc_strict_flags])
elif test "${enable_c89}" = "yes" ; then
PAC_APPEND_FLAG([-std=c89],[pac_cc_strict_flags])
fi
fi
# See if the above options work with the compiler
accepted_flags=""
for flag in $pac_cc_strict_flags ; do
PAC_PUSH_FLAG([CFLAGS])
CFLAGS="$CFLAGS $accepted_flags"
PAC_C_CHECK_COMPILER_OPTION([$flag],[accepted_flags="$accepted_flags $flag"],)
PAC_POP_FLAG([CFLAGS])
done
pac_cc_strict_flags=$accepted_flags
fi
])
dnl/*D
dnl PAC_ARG_STRICT - Add --enable-strict to configure.
dnl
dnl Synopsis:
dnl PAC_ARG_STRICT
dnl
dnl Output effects:
dnl Adds '--enable-strict' to the command line.
dnl
dnl D*/
AC_DEFUN([PAC_ARG_STRICT],[
AC_ARG_ENABLE(strict,
AC_HELP_STRING([--enable-strict], [Turn on strict compilation testing]))
PAC_CC_STRICT($enable_strict)
CFLAGS="$CFLAGS $pac_cc_strict_flags"
export CFLAGS
])
dnl Return the integer structure alignment in pac_cv_c_max_integer_align
dnl Possible values include
dnl packed
dnl two
dnl four
dnl eight
dnl
dnl In addition, a "Could not determine alignment" and a "error!"
dnl return is possible.
AC_DEFUN([PAC_C_MAX_INTEGER_ALIGN],[
AC_CACHE_CHECK([for max C struct integer alignment],
pac_cv_c_max_integer_align,[
AC_TRY_RUN([
#include
#define DBG(a,b,c)
int main( int argc, char *argv[] )
{
FILE *cf;
int is_packed = 1;
int is_two = 1;
int is_four = 1;
int is_eight = 1;
struct { char a; int b; } char_int;
struct { char a; short b; } char_short;
struct { char a; long b; } char_long;
struct { char a; int b; char c; } char_int_char;
struct { char a; short b; char c; } char_short_char;
#ifdef HAVE_LONG_LONG_INT
struct { long long int a; char b; } lli_c;
struct { char a; long long int b; } c_lli;
#endif
int size, extent, extent2;
/* assume max integer alignment isn't 8 if we don't have
* an eight-byte value :)
*/
#ifdef HAVE_LONG_LONG_INT
if (sizeof(int) < 8 && sizeof(long) < 8 && sizeof(long long int) < 8)
is_eight = 0;
#else
if (sizeof(int) < 8 && sizeof(long) < 8) is_eight = 0;
#endif
size = sizeof(char) + sizeof(int);
extent = sizeof(char_int);
if (size != extent) is_packed = 0;
if ( (extent % 2) != 0) is_two = 0;
if ( (extent % 4) != 0) is_four = 0;
if (sizeof(int) == 8 && (extent % 8) != 0) is_eight = 0;
DBG("char_int",size,extent);
size = sizeof(char) + sizeof(short);
extent = sizeof(char_short);
if (size != extent) is_packed = 0;
if ( (extent % 2) != 0) is_two = 0;
if (sizeof(short) == 4 && (extent % 4) != 0) is_four = 0;
if (sizeof(short) == 8 && (extent % 8) != 0) is_eight = 0;
DBG("char_short",size,extent);
size = sizeof(char) + sizeof(long);
extent = sizeof(char_long);
if (size != extent) is_packed = 0;
if ( (extent % 2) != 0) is_two = 0;
if ( (extent % 4) != 0) is_four = 0;
if (sizeof(long) == 8 && (extent % 8) != 0) is_eight = 0;
DBG("char_long",size,extent);
#ifdef HAVE_LONG_LONG_INT
size = sizeof(char) + sizeof(long long int);
extent = sizeof(lli_c);
extent2 = sizeof(c_lli);
if (size != extent) is_packed = 0;
if ( (extent % 2) != 0 && (extent2 % 2) != 0) is_two = 0;
if ( (extent % 4) != 0 && (extent2 % 4) != 0) is_four = 0;
if (sizeof(long long int) >= 8 && (extent % 8) != 0 && (extent2 % 8) != 0)
is_eight = 0;
#endif
size = sizeof(char) + sizeof(int) + sizeof(char);
extent = sizeof(char_int_char);
if (size != extent) is_packed = 0;
if ( (extent % 2) != 0) is_two = 0;
if ( (extent % 4) != 0) is_four = 0;
if (sizeof(int) == 8 && (extent % 8) != 0) is_eight = 0;
DBG("char_int_char",size,extent);
size = sizeof(char) + sizeof(short) + sizeof(char);
extent = sizeof(char_short_char);
if (size != extent) is_packed = 0;
if ( (extent % 2) != 0) is_two = 0;
if (sizeof(short) == 4 && (extent % 4) != 0) is_four = 0;
if (sizeof(short) == 8 && (extent % 8) != 0) is_eight = 0;
DBG("char_short_char",size,extent);
/* If aligned mod 8, it will be aligned mod 4 */
if (is_eight) { is_four = 0; is_two = 0; }
if (is_four) is_two = 0;
/* Tabulate the results */
cf = fopen( "ctest.out", "w" );
if (is_packed + is_two + is_four + is_eight == 0) {
fprintf( cf, "Could not determine alignment\n" );
}
else {
if (is_packed + is_two + is_four + is_eight != 1) {
fprintf( cf, "error!\n" );
}
else {
if (is_packed) fprintf( cf, "packed\n" );
if (is_two) fprintf( cf, "two\n" );
if (is_four) fprintf( cf, "four\n" );
if (is_eight) fprintf( cf, "eight\n" );
}
}
fclose( cf );
return 0;
}],
pac_cv_c_max_integer_align=`cat ctest.out`,
pac_cv_c_max_integer_align="unknown",
pac_cv_c_max_integer_align="$CROSS_ALIGN_STRUCT_INT")
rm -f ctest.out
])
if test -z "$pac_cv_c_max_integer_align" ; then
pac_cv_c_max_integer_align="unknown"
fi
])
dnl Return the floating point structure alignment in
dnl pac_cv_c_max_fp_align.
dnl
dnl Possible values include:
dnl packed
dnl two
dnl four
dnl eight
dnl sixteen
dnl
dnl In addition, a "Could not determine alignment" and a "error!"
dnl return is possible.
AC_DEFUN([PAC_C_MAX_FP_ALIGN],[
AC_CACHE_CHECK([for max C struct floating point alignment],
pac_cv_c_max_fp_align,[
AC_TRY_RUN([
#include
#define DBG(a,b,c)
int main( int argc, char *argv[] )
{
FILE *cf;
int is_packed = 1;
int is_two = 1;
int is_four = 1;
int is_eight = 1;
int is_sixteen = 1;
struct { char a; float b; } char_float;
struct { float b; char a; } float_char;
struct { char a; double b; } char_double;
struct { double b; char a; } double_char;
#ifdef HAVE_LONG_DOUBLE
struct { char a; long double b; } char_long_double;
struct { long double b; char a; } long_double_char;
struct { long double a; int b; char c; } long_double_int_char;
#endif
int size, extent1, extent2;
size = sizeof(char) + sizeof(float);
extent1 = sizeof(char_float);
extent2 = sizeof(float_char);
if (size != extent1) is_packed = 0;
if ( (extent1 % 2) != 0 && (extent2 % 2) != 0) is_two = 0;
if ( (extent1 % 4) != 0 && (extent2 % 4) != 0) is_four = 0;
if (sizeof(float) == 8 && (extent1 % 8) != 0 && (extent2 % 8) != 0)
is_eight = 0;
DBG("char_float",size,extent1);
size = sizeof(char) + sizeof(double);
extent1 = sizeof(char_double);
extent2 = sizeof(double_char);
if (size != extent1) is_packed = 0;
if ( (extent1 % 2) != 0 && (extent2 % 2) != 0) is_two = 0;
if ( (extent1 % 4) != 0 && (extent2 % 4) != 0) is_four = 0;
if (sizeof(double) == 8 && (extent1 % 8) != 0 && (extent2 % 8) != 0)
is_eight = 0;
DBG("char_double",size,extent1);
#ifdef HAVE_LONG_DOUBLE
size = sizeof(char) + sizeof(long double);
extent1 = sizeof(char_long_double);
extent2 = sizeof(long_double_char);
if (size != extent1) is_packed = 0;
if ( (extent1 % 2) != 0 && (extent2 % 2) != 0) is_two = 0;
if ( (extent1 % 4) != 0 && (extent2 % 4) != 0) is_four = 0;
if (sizeof(long double) >= 8 && (extent1 % 8) != 0 && (extent2 % 8) != 0)
is_eight = 0;
if (sizeof(long double) > 8 && (extent1 % 16) != 0
&& (extent2 % 16) != 0) is_sixteen = 0;
DBG("char_long-double",size,extent1);
extent1 = sizeof(long_double_int_char);
if ( (extent1 % 2) != 0) is_two = 0;
if ( (extent1 % 4) != 0) is_four = 0;
if (sizeof(long double) >= 8 && (extent1 % 8) != 0) is_eight = 0;
if (sizeof(long double) > 8 && (extent1 % 16) != 0) is_sixteen = 0;
#else
is_sixteen = 0;
#endif
if (is_sixteen) { is_eight = 0; is_four = 0; is_two = 0; }
if (is_eight) { is_four = 0; is_two = 0; }
if (is_four) is_two = 0;
/* Tabulate the results */
cf = fopen( "ctest.out", "w" );
if (is_packed + is_two + is_four + is_eight + is_sixteen == 0) {
fprintf( cf, "Could not determine alignment\n" );
}
else {
if (is_packed + is_two + is_four + is_eight + is_sixteen != 1) {
fprintf( cf, "error!\n" );
}
else {
if (is_packed) fprintf( cf, "packed\n" );
if (is_two) fprintf( cf, "two\n" );
if (is_four) fprintf( cf, "four\n" );
if (is_eight) fprintf( cf, "eight\n" );
if (is_sixteen) fprintf( cf, "sixteen\n" );
}
}
fclose( cf );
return 0;
}],
pac_cv_c_max_fp_align=`cat ctest.out`,
pac_cv_c_max_fp_align="unknown",
pac_cv_c_max_fp_align="$CROSS_ALIGN_STRUCT_FP")
rm -f ctest.out
])
if test -z "$pac_cv_c_max_fp_align" ; then
pac_cv_c_max_fp_align="unknown"
fi
])
dnl Return the floating point structure alignment in
dnl pac_cv_c_max_double_fp_align.
dnl
dnl Possible values include:
dnl packed
dnl two
dnl four
dnl eight
dnl
dnl In addition, a "Could not determine alignment" and a "error!"
dnl return is possible.
AC_DEFUN([PAC_C_MAX_DOUBLE_FP_ALIGN],[
AC_CACHE_CHECK([for max C struct alignment of structs with doubles],
pac_cv_c_max_double_fp_align,[
AC_TRY_RUN([
#include
#define DBG(a,b,c)
int main( int argc, char *argv[] )
{
FILE *cf;
int is_packed = 1;
int is_two = 1;
int is_four = 1;
int is_eight = 1;
struct { char a; float b; } char_float;
struct { float b; char a; } float_char;
struct { char a; double b; } char_double;
struct { double b; char a; } double_char;
int size, extent1, extent2;
size = sizeof(char) + sizeof(float);
extent1 = sizeof(char_float);
extent2 = sizeof(float_char);
if (size != extent1) is_packed = 0;
if ( (extent1 % 2) != 0 && (extent2 % 2) != 0) is_two = 0;
if ( (extent1 % 4) != 0 && (extent2 % 4) != 0) is_four = 0;
if (sizeof(float) == 8 && (extent1 % 8) != 0 && (extent2 % 8) != 0)
is_eight = 0;
DBG("char_float",size,extent1);
size = sizeof(char) + sizeof(double);
extent1 = sizeof(char_double);
extent2 = sizeof(double_char);
if (size != extent1) is_packed = 0;
if ( (extent1 % 2) != 0 && (extent2 % 2) != 0) is_two = 0;
if ( (extent1 % 4) != 0 && (extent2 % 4) != 0) is_four = 0;
if (sizeof(double) == 8 && (extent1 % 8) != 0 && (extent2 % 8) != 0)
is_eight = 0;
DBG("char_double",size,extent1);
if (is_eight) { is_four = 0; is_two = 0; }
if (is_four) is_two = 0;
/* Tabulate the results */
cf = fopen( "ctest.out", "w" );
if (is_packed + is_two + is_four + is_eight == 0) {
fprintf( cf, "Could not determine alignment\n" );
}
else {
if (is_packed + is_two + is_four + is_eight != 1) {
fprintf( cf, "error!\n" );
}
else {
if (is_packed) fprintf( cf, "packed\n" );
if (is_two) fprintf( cf, "two\n" );
if (is_four) fprintf( cf, "four\n" );
if (is_eight) fprintf( cf, "eight\n" );
}
}
fclose( cf );
return 0;
}],
pac_cv_c_max_double_fp_align=`cat ctest.out`,
pac_cv_c_max_double_fp_align="unknown",
pac_cv_c_max_double_fp_align="$CROSS_ALIGN_STRUCT_DOUBLE_FP")
rm -f ctest.out
])
if test -z "$pac_cv_c_max_double_fp_align" ; then
pac_cv_c_max_double_fp_align="unknown"
fi
])
AC_DEFUN([PAC_C_MAX_LONGDOUBLE_FP_ALIGN],[
AC_CACHE_CHECK([for max C struct floating point alignment with long doubles],
pac_cv_c_max_longdouble_fp_align,[
AC_TRY_RUN([
#include
#define DBG(a,b,c)
int main( int argc, char *argv[] )
{
FILE *cf;
int is_packed = 1;
int is_two = 1;
int is_four = 1;
int is_eight = 1;
int is_sixteen = 1;
struct { char a; long double b; } char_long_double;
struct { long double b; char a; } long_double_char;
struct { long double a; int b; char c; } long_double_int_char;
int size, extent1, extent2;
size = sizeof(char) + sizeof(long double);
extent1 = sizeof(char_long_double);
extent2 = sizeof(long_double_char);
if (size != extent1) is_packed = 0;
if ( (extent1 % 2) != 0 && (extent2 % 2) != 0) is_two = 0;
if ( (extent1 % 4) != 0 && (extent2 % 4) != 0) is_four = 0;
if (sizeof(long double) >= 8 && (extent1 % 8) != 0 && (extent2 % 8) != 0)
is_eight = 0;
if (sizeof(long double) > 8 && (extent1 % 16) != 0
&& (extent2 % 16) != 0) is_sixteen = 0;
DBG("char_long-double",size,extent1);
extent1 = sizeof(long_double_int_char);
if ( (extent1 % 2) != 0) is_two = 0;
if ( (extent1 % 4) != 0) is_four = 0;
if (sizeof(long double) >= 8 && (extent1 % 8) != 0) is_eight = 0;
if (sizeof(long double) > 8 && (extent1 % 16) != 0) is_sixteen = 0;
if (is_sixteen) { is_eight = 0; is_four = 0; is_two = 0; }
if (is_eight) { is_four = 0; is_two = 0; }
if (is_four) is_two = 0;
/* Tabulate the results */
cf = fopen( "ctest.out", "w" );
if (is_packed + is_two + is_four + is_eight + is_sixteen == 0) {
fprintf( cf, "Could not determine alignment\n" );
}
else {
if (is_packed + is_two + is_four + is_eight + is_sixteen != 1) {
fprintf( cf, "error!\n" );
}
else {
if (is_packed) fprintf( cf, "packed\n" );
if (is_two) fprintf( cf, "two\n" );
if (is_four) fprintf( cf, "four\n" );
if (is_eight) fprintf( cf, "eight\n" );
if (is_sixteen) fprintf( cf, "sixteen\n" );
}
}
fclose( cf );
return 0;
}],
pac_cv_c_max_longdouble_fp_align=`cat ctest.out`,
pac_cv_c_max_longdouble_fp_align="unknown",
pac_cv_c_max_longdouble_fp_align="$CROSS_ALIGN_STRUCT_LONGDOUBLE_FP")
rm -f ctest.out
])
if test -z "$pac_cv_c_max_longdouble_fp_align" ; then
pac_cv_c_max_longdouble_fp_align="unknown"
fi
])
dnl Other tests assume that there is potentially a maximum alignment
dnl and that if there is no maximum alignment, or a type is smaller than
dnl that value, then we align on the size of the value, with the exception
dnl of the "position-based alignment" rules we test for separately.
dnl
dnl It turns out that these assumptions have fallen short in at least one
dnl case, on MacBook Pros, where doubles are aligned on 4-byte boundaries
dnl even when long doubles are aligned on 16-byte boundaries. So this test
dnl is here specifically to handle this case.
dnl
dnl Puts result in pac_cv_c_double_alignment_exception.
dnl
dnl Possible values currently include no and four.
dnl
AC_DEFUN([PAC_C_DOUBLE_ALIGNMENT_EXCEPTION],[
AC_CACHE_CHECK([if double alignment breaks rules, find actual alignment],
pac_cv_c_double_alignment_exception,[
AC_TRY_RUN([
#include
#define DBG(a,b,c)
int main( int argc, char *argv[] )
{
FILE *cf;
struct { char a; double b; } char_double;
struct { double b; char a; } double_char;
int extent1, extent2, align_4 = 0;
extent1 = sizeof(char_double);
extent2 = sizeof(double_char);
/* we're interested in the largest value, will let separate test
* deal with position-based issues.
*/
if (extent1 < extent2) extent1 = extent2;
if ((sizeof(double) == 8) && (extent1 % 8) != 0) {
if (extent1 % 4 == 0) {
#ifdef HAVE_MAX_FP_ALIGNMENT
if (HAVE_MAX_FP_ALIGNMENT >= 8) align_4 = 1;
#else
align_4 = 1;
#endif
}
}
cf = fopen( "ctest.out", "w" );
if (align_4) fprintf( cf, "four\n" );
else fprintf( cf, "no\n" );
fclose( cf );
return 0;
}],
pac_cv_c_double_alignment_exception=`cat ctest.out`,
pac_cv_c_double_alignment_exception="unknown",
pac_cv_c_double_alignment_exception="$CROSS_ALIGN_DOUBLE_EXCEPTION")
rm -f ctest.out
])
if test -z "$pac_cv_c_double_alignment_exception" ; then
pac_cv_c_double_alignment_exception="unknown"
fi
])
dnl Test for odd struct alignment rule that only applies max.
dnl padding when double value is at front of type.
dnl Puts result in pac_cv_c_double_pos_align.
dnl
dnl Search for "Power alignment mode" for more details.
dnl
dnl Possible values include yes, no, and unknown.
dnl
AC_DEFUN([PAC_C_DOUBLE_POS_ALIGN],[
AC_CACHE_CHECK([if alignment of structs with doubles is based on position],
pac_cv_c_double_pos_align,[
AC_TRY_RUN([
#include
#define DBG(a,b,c)
int main( int argc, char *argv[] )
{
FILE *cf;
int padding_varies_by_pos = 0;
struct { char a; double b; } char_double;
struct { double b; char a; } double_char;
int extent1, extent2;
extent1 = sizeof(char_double);
extent2 = sizeof(double_char);
if (extent1 != extent2) padding_varies_by_pos = 1;
cf = fopen( "ctest.out", "w" );
if (padding_varies_by_pos) fprintf( cf, "yes\n" );
else fprintf( cf, "no\n" );
fclose( cf );
return 0;
}],
pac_cv_c_double_pos_align=`cat ctest.out`,
pac_cv_c_double_pos_align="unknown",
pac_cv_c_double_pos_align="$CROSS_ALIGN_DOUBLE_POS")
rm -f ctest.out
])
if test -z "$pac_cv_c_double_pos_align" ; then
pac_cv_c_double_pos_align="unknown"
fi
])
dnl Test for odd struct alignment rule that only applies max.
dnl padding when long long int value is at front of type.
dnl Puts result in pac_cv_c_llint_pos_align.
dnl
dnl Search for "Power alignment mode" for more details.
dnl
dnl Possible values include yes, no, and unknown.
dnl
AC_DEFUN([PAC_C_LLINT_POS_ALIGN],[
AC_CACHE_CHECK([if alignment of structs with long long ints is based on position],
pac_cv_c_llint_pos_align,[
AC_TRY_RUN([
#include
#define DBG(a,b,c)
int main( int argc, char *argv[] )
{
FILE *cf;
int padding_varies_by_pos = 0;
#ifdef HAVE_LONG_LONG_INT
struct { char a; long long int b; } char_llint;
struct { long long int b; char a; } llint_char;
int extent1, extent2;
extent1 = sizeof(char_llint);
extent2 = sizeof(llint_char);
if (extent1 != extent2) padding_varies_by_pos = 1;
#endif
cf = fopen( "ctest.out", "w" );
if (padding_varies_by_pos) fprintf( cf, "yes\n" );
else fprintf( cf, "no\n" );
fclose( cf );
return 0;
}],
pac_cv_c_llint_pos_align=`cat ctest.out`,
pac_cv_c_llint_pos_align="unknown",
pac_cv_c_llint_pos_align="$CROSS_ALIGN_LLINT_POS")
rm -f ctest.out
])
if test -z "$pac_cv_c_llint_pos_align" ; then
pac_cv_c_llint_pos_align="unknown"
fi
])
dnl/*D
dnl PAC_FUNC_NEEDS_DECL - Set NEEDS__DECL if a declaration is needed
dnl
dnl Synopsis:
dnl PAC_FUNC_NEEDS_DECL(headerfiles,funcname)
dnl
dnl Output Effect:
dnl Sets 'NEEDS__DECL' if 'funcname' is not declared by the
dnl headerfiles.
dnl
dnl Approach:
dnl Try to compile a program with the function, but passed with an incorrect
dnl calling sequence. If the compilation fails, then the declaration
dnl is provided within the header files. If the compilation succeeds,
dnl the declaration is required.
dnl
dnl We use a 'double' as the first argument to try and catch varargs
dnl routines that may use an int or pointer as the first argument.
dnl
dnl There is one difficulty - if the compiler has been instructed to
dnl fail on implicitly defined functions, then this test will always
dnl fail.
dnl
dnl D*/
AC_DEFUN([PAC_FUNC_NEEDS_DECL],[
AC_CACHE_CHECK([whether $2 needs a declaration],
pac_cv_func_decl_$2,[
AC_TRY_COMPILE([$1
int $2(double, int, double, const char *);],[int a=$2(1.0,27,1.0,"foo");],
pac_cv_func_decl_$2=yes,pac_cv_func_decl_$2=no)])
if test "$pac_cv_func_decl_$2" = "yes" ; then
changequote(<<,>>)dnl
define(<>, translit(NEEDS_$2_DECL, [a-z *], [A-Z__]))dnl
changequote([, ])dnl
AC_DEFINE_UNQUOTED(PAC_FUNC_NAME,1,[Define if $2 needs a declaration])
undefine([PAC_FUNC_NAME])
fi
])
dnl PAC_C_GNU_ATTRIBUTE - See if the GCC __attribute__ specifier is allow.
dnl Use the following
dnl #ifndef HAVE_GCC_ATTRIBUTE
dnl #define __attribute__(a)
dnl #endif
dnl If *not*, define __attribute__(a) as null
dnl
dnl We start by requiring Gcc. Some other compilers accept __attribute__
dnl but generate warning messages, or have different interpretations
dnl (which seems to make __attribute__ just as bad as #pragma)
dnl For example, the Intel icc compiler accepts __attribute__ and
dnl __attribute__((pure)) but generates warnings for __attribute__((format...))
dnl
AC_DEFUN([PAC_C_GNU_ATTRIBUTE],[
AC_REQUIRE([AC_PROG_CC_GNU])
if test "$ac_cv_prog_gcc" = "yes" ; then
AC_CACHE_CHECK([whether __attribute__ allowed],
pac_cv_gnu_attr_pure,[
AC_TRY_COMPILE([int foo(int) __attribute__ ((pure));],[int a;],
pac_cv_gnu_attr_pure=yes,pac_cv_gnu_attr_pure=no)])
AC_CACHE_CHECK([whether __attribute__((format)) allowed],
pac_cv_gnu_attr_format,[
AC_TRY_COMPILE([int foo(char *,...) __attribute__ ((format(printf,1,2)));],[int a;],
pac_cv_gnu_attr_format=yes,pac_cv_gnu_attr_format=no)])
if test "$pac_cv_gnu_attr_pure" = "yes" -a "$pac_cv_gnu_attr_format" = "yes" ; then
AC_DEFINE(HAVE_GCC_ATTRIBUTE,1,[Define if GNU __attribute__ is supported])
fi
fi
])
dnl
dnl Check for a broken install (fails to preserve file modification times,
dnl thus breaking libraries.
dnl
dnl Create a library, install it, and then try to link against it.
AC_DEFUN([PAC_PROG_INSTALL_BREAKS_LIBS],[
AC_CACHE_CHECK([whether install breaks libraries],
ac_cv_prog_install_breaks_libs,[
AC_REQUIRE([AC_PROG_RANLIB])
AC_REQUIRE([AC_PROG_INSTALL])
AC_REQUIRE([AC_PROG_CC])
ac_cv_prog_install_breaks_libs=yes
# This is needed for Mac OSX 10.5
rm -rf conftest.dSYM
rm -f libconftest* conftest*
echo 'int foo(int);int foo(int a){return a;}' > conftest1.c
echo 'extern int foo(int); int main( int argc, char **argv){ return foo(0); }' > conftest2.c
if ${CC-cc} $CFLAGS -c conftest1.c >conftest.out 2>&1 ; then
if ${AR-ar} cr libconftest.a conftest1.o >/dev/null 2>&1 ; then
if ${RANLIB-:} libconftest.a >/dev/null 2>&1 ; then
# Anything less than sleep 10, and Mac OS/X (Darwin)
# will claim that install works because ranlib won't complain
sleep 10
libinstall="$INSTALL_DATA"
eval "libinstall=\"$libinstall\""
if ${libinstall} libconftest.a libconftest1.a >/dev/null 2>&1 ; then
if ${CC-cc} $CFLAGS -o conftest conftest2.c $LDFLAGS libconftest1.a >>conftest.out 2>&1 && test -x conftest ; then
# Success! Install works
ac_cv_prog_install_breaks_libs=no
else
# Failure! Does install -p work?
rm -f libconftest1.a
if ${libinstall} -p libconftest.a libconftest1.a >/dev/null 2>&1 ; then
if ${CC-cc} $CFLAGS -o conftest conftest2.c $LDFLAGS libconftest1.a >>conftest.out 2>&1 && test -x conftest ; then
# Success! Install works
ac_cv_prog_install_breaks_libs="no, with -p"
fi
fi
fi
fi
fi
fi
fi
# This is needed for Mac OSX 10.5
rm -rf conftest.dSYM
rm -f conftest* libconftest*])
if test -z "$RANLIB_AFTER_INSTALL" ; then
RANLIB_AFTER_INSTALL=no
fi
case "$ac_cv_prog_install_breaks_libs" in
yes)
RANLIB_AFTER_INSTALL=yes
;;
"no, with -p")
INSTALL_DATA="$INSTALL_DATA -p"
;;
*)
# Do nothing
:
;;
esac
AC_SUBST(RANLIB_AFTER_INSTALL)
])
#
# determine if the compiler defines a symbol containing the function name
# Inspired by checks within the src/mpid/globus/configure.in file in MPICH2
#
# These tests check not only that the compiler defines some symbol, such
# as __FUNCTION__, but that the symbol correctly names the function.
#
# Defines
# HAVE__FUNC__ (if __func__ defined)
# HAVE_CAP__FUNC__ (if __FUNC__ defined)
# HAVE__FUNCTION__ (if __FUNCTION__ defined)
#
AC_DEFUN([PAC_CC_FUNCTION_NAME_SYMBOL],[
AC_CACHE_CHECK([whether the compiler defines __func__],
pac_cv_have__func__,[
tmp_am_cross=no
AC_RUN_IFELSE([
AC_LANG_SOURCE([
#include
int foo(void);
int foo(void)
{
return (strcmp(__func__, "foo") == 0);
}
int main(int argc, char ** argv)
{
return (foo() ? 0 : 1);
}
])
], pac_cv_have__func__=yes, pac_cv_have__func__=no,tmp_am_cross=yes)
if test "$tmp_am_cross" = yes ; then
AC_LINK_IFELSE([
AC_LANG_SOURCE([
#include
int foo(void);
int foo(void)
{
return (strcmp(__func__, "foo") == 0);
}
int main(int argc, char ** argv)
{
return (foo() ? 0 : 1);
}
])
], pac_cv_have__func__=yes, pac_cv_have__func__=no)
fi
])
if test "$pac_cv_have__func__" = "yes" ; then
AC_DEFINE(HAVE__FUNC__,,[define if the compiler defines __func__])
fi
AC_CACHE_CHECK([whether the compiler defines __FUNC__],
pac_cv_have_cap__func__,[
tmp_am_cross=no
AC_RUN_IFELSE([
AC_LANG_SOURCE([
#include
int foo(void);
int foo(void)
{
return (strcmp(__FUNC__, "foo") == 0);
}
int main(int argc, char ** argv)
{
return (foo() ? 0 : 1);
}
])
], pac_cv_have_cap__func__=yes, pac_cv_have_cap__func__=no,tmp_am_cross=yes)
if test "$tmp_am_cross" = yes ; then
AC_LINK_IFELSE([
AC_LANG_SOURCE([
#include
int foo(void);
int foo(void)
{
return (strcmp(__FUNC__, "foo") == 0);
}
int main(int argc, char ** argv)
{
return (foo() ? 0 : 1);
}
])
], pac_cv_have__func__=yes, pac_cv_have__func__=no)
fi
])
if test "$pac_cv_have_cap__func__" = "yes" ; then
AC_DEFINE(HAVE_CAP__FUNC__,,[define if the compiler defines __FUNC__])
fi
AC_CACHE_CHECK([whether the compiler sets __FUNCTION__],
pac_cv_have__function__,[
tmp_am_cross=no
AC_RUN_IFELSE([
AC_LANG_SOURCE([
#include
int foo(void);
int foo(void)
{
return (strcmp(__FUNCTION__, "foo") == 0);
}
int main(int argc, char ** argv)
{
return (foo() ? 0 : 1);
}
])
], pac_cv_have__function__=yes, pac_cv_have__function__=no,tmp_am_cross=yes)
if test "$tmp_am_cross" = yes ; then
AC_LINK_IFELSE([
AC_LANG_SOURCE([
#include
int foo(void);
int foo(void)
{
return (strcmp(__FUNCTION__, "foo") == 0);
}
int main(int argc, char ** argv)
{
return (foo() ? 0 : 1);
}
])
], pac_cv_have__func__=yes, pac_cv_have__func__=no)
fi
])
if test "$pac_cv_have__function__" = "yes" ; then
AC_DEFINE(HAVE__FUNCTION__,,[define if the compiler defines __FUNCTION__])
fi
])
dnl Check structure alignment
AC_DEFUN([PAC_STRUCT_ALIGNMENT],[
# Initialize alignment checks
is_packed=1
is_two=1
is_four=1
is_eight=1
is_largest=1
# See if long double exists
AC_TRY_COMPILE(,[long double a;],have_long_double=yes,have_long_double=no)
# Get sizes of regular types
AC_CHECK_SIZEOF(char)
AC_CHECK_SIZEOF(int)
AC_CHECK_SIZEOF(short)
AC_CHECK_SIZEOF(long)
AC_CHECK_SIZEOF(float)
AC_CHECK_SIZEOF(double)
AC_CHECK_SIZEOF(long double)
# char_int comparison
AC_CHECK_SIZEOF(char_int, 0, [typedef struct { char a; int b; } char_int; ])
size=`expr $ac_cv_sizeof_char + $ac_cv_sizeof_int`
extent=$ac_cv_sizeof_char_int
if test "$size" != "$extent" ; then is_packed=0 ; fi
if test "`expr $extent % $ac_cv_sizeof_int`" != "0" ; then is_largest=0 ; fi
if test "`expr $extent % 2`" != "0" ; then is_two=0 ; fi
if test "`expr $extent % 4`" != "0" ; then is_four=0 ; fi
if test "$ac_cv_sizeof_int" = "8" -a "`expr $extent % 8`" != "0" ; then
is_eight=0
fi
# char_short comparison
AC_CHECK_SIZEOF(char_short, 0, [typedef struct { char a; short b; } char_short; ])
size=`expr $ac_cv_sizeof_char + $ac_cv_sizeof_short`
extent=$ac_cv_sizeof_char_short
if test "$size" != "$extent" ; then is_packed=0 ; fi
if test "`expr $extent % $ac_cv_sizeof_short`" != "0" ; then is_largest=0 ; fi
if test "`expr $extent % 2`" != "0" ; then is_two=0 ; fi
if test "$ac_cv_sizeof_short" = "4" -a "`expr $extent % 4`" != "0" ; then
is_four=0
fi
if test "$ac_cv_sizeof_short" = "8" -a "`expr $extent % 8`" != "0" ; then
is_eight=0
fi
# char_long comparison
AC_CHECK_SIZEOF(char_long, 0, [typedef struct { char a; long b; } char_long; ])
size=`expr $ac_cv_sizeof_char + $ac_cv_sizeof_long`
extent=$ac_cv_sizeof_char_long
if test "$size" != "$extent" ; then is_packed=0 ; fi
if test "`expr $extent % $ac_cv_sizeof_long`" != "0" ; then is_largest=0 ; fi
if test "`expr $extent % 2`" != "0" ; then is_two=0 ; fi
if test "`expr $extent % 4`" != "0" ; then is_four=0 ; fi
if test "$ac_cv_sizeof_long" = "8" -a "`expr $extent % 8`" != "0" ; then
is_eight=0
fi
# char_float comparison
AC_CHECK_SIZEOF(char_float, 0, [typedef struct { char a; float b; } char_float; ])
size=`expr $ac_cv_sizeof_char + $ac_cv_sizeof_float`
extent=$ac_cv_sizeof_char_float
if test "$size" != "$extent" ; then is_packed=0 ; fi
if test "`expr $extent % $ac_cv_sizeof_float`" != "0" ; then is_largest=0 ; fi
if test "`expr $extent % 2`" != "0" ; then is_two=0 ; fi
if test "`expr $extent % 4`" != "0" ; then is_four=0 ; fi
if test "$ac_cv_sizeof_float" = "8" -a "`expr $extent % 8`" != "0" ; then
is_eight=0
fi
# char_double comparison
AC_CHECK_SIZEOF(char_double, 0, [typedef struct { char a; double b; } char_double; ])
size=`expr $ac_cv_sizeof_char + $ac_cv_sizeof_double`
extent=$ac_cv_sizeof_char_double
if test "$size" != "$extent" ; then is_packed=0 ; fi
if test "`expr $extent % $ac_cv_sizeof_double`" != "0" ; then is_largest=0 ; fi
if test "`expr $extent % 2`" != "0" ; then is_two=0 ; fi
if test "`expr $extent % 4`" != "0" ; then is_four=0 ; fi
if test "$ac_cv_sizeof_double" = "8" -a "`expr $extent % 8`" != "0" ; then
is_eight=0
fi
# char_long_double comparison
if test "$have_long_double" = "yes"; then
AC_CHECK_SIZEOF(char_long_double, 0, [
typedef struct {
char a;
long double b;
} char_long_double;
])
size=`expr $ac_cv_sizeof_char + $ac_cv_sizeof_long_double`
extent=$ac_cv_sizeof_char_long_double
if test "$size" != "$extent" ; then is_packed=0 ; fi
if test "`expr $extent % $ac_cv_sizeof_long_double`" != "0" ; then is_largest=0 ; fi
if test "`expr $extent % 2`" != "0" ; then is_two=0 ; fi
if test "`expr $extent % 4`" != "0" ; then is_four=0 ; fi
if test "$ac_cv_sizeof_long_double" = "8" -a "`expr $extent % 8`" != "0" ; then
is_eight=0
fi
fi
# char_int_char comparison
AC_CHECK_SIZEOF(char_int_char, 0, [
typedef struct {
char a;
int b;
char c;
} char_int_char;
])
size=`expr $ac_cv_sizeof_char + $ac_cv_sizeof_int + $ac_cv_sizeof_char`
extent=$ac_cv_sizeof_char_int_char
if test "$size" != "$extent" ; then is_packed=0 ; fi
if test "`expr $extent % $ac_cv_sizeof_int`" != "0" ; then is_largest=0 ; fi
if test "`expr $extent % 2`" != "0" ; then is_two=0 ; fi
if test "`expr $extent % 4`" != "0" ; then is_four=0 ; fi
if test "$ac_cv_sizeof_int" = "8" -a "`expr $extent % 8`" != "0" ; then
is_eight=0
fi
# char_short_char comparison
AC_CHECK_SIZEOF(char_short_char, 0, [
typedef struct {
char a;
short b;
char c;
} char_short_char;
])
size=`expr $ac_cv_sizeof_char + $ac_cv_sizeof_short + $ac_cv_sizeof_char`
extent=$ac_cv_sizeof_char_short_char
if test "$size" != "$extent" ; then is_packed=0 ; fi
if test "`expr $extent % $ac_cv_sizeof_short`" != "0" ; then is_largest=0 ; fi
if test "`expr $extent % 2`" != "0" ; then is_two=0 ; fi
if test "$ac_cv_sizeof_short" = "4" -a "`expr $extent % 4`" != "0" ; then
is_four=0
fi
if test "$ac_cv_sizeof_short" = "8" -a "`expr $extent % 8`" != "0" ; then
is_eight=0
fi
# If aligned mod 8, it will be aligned mod 4
if test $is_eight = 1 ; then is_four=0 ; is_two=0 ; fi
if test $is_four = 1 ; then is_two=0 ; fi
# Largest supersedes 8
if test $is_largest = 1 ; then is_eight=0 ; fi
# Find the alignment
if test "`expr $is_packed + $is_largest + $is_two + $is_four + $is_eight`" = "0" ; then
pac_cv_struct_alignment="unknown"
elif test "`expr $is_packed + $is_largest + $is_two + $is_four + $is_eight`" != "1" ; then
pac_cv_struct_alignment="unknown"
elif test $is_packed = 1 ; then
pac_cv_struct_alignment="packed"
elif test $is_largest = 1 ; then
pac_cv_struct_alignment="largest"
elif test $is_two = 1 ; then
pac_cv_struct_alignment="two"
elif test $is_four = 1 ; then
pac_cv_struct_alignment="four"
elif test $is_eight = 1 ; then
pac_cv_struct_alignment="eight"
fi
])
dnl
dnl PAC_C_MACRO_VA_ARGS
dnl
dnl will AC_DEFINE([HAVE_MACRO_VA_ARGS]) if the compiler supports C99 variable
dnl length argument lists in macros (#define foo(...) bar(__VA_ARGS__))
AC_DEFUN([PAC_C_MACRO_VA_ARGS],[
AC_MSG_CHECKING([for variable argument list macro functionality])
AC_LINK_IFELSE([AC_LANG_PROGRAM([
#include
#define conftest_va_arg_macro(...) printf(__VA_ARGS__)
],
[conftest_va_arg_macro("a test %d", 3);])],
[AC_DEFINE([HAVE_MACRO_VA_ARGS],[1],[Define if C99-style variable argument list macro functionality])
AC_MSG_RESULT([yes])],
[AC_MSG_RESULT([no])])
])dnl
armci-mpi/m4/aclocal_atomic.m4 0000644 0001750 0001750 00000016607 12662706250 015740 0 ustar mbanck mbanck dnl /*D PAC_C_MEMATOMIC - Try and determine how to implement memory-atomic
dnl operations with the selected C compiler
dnl
dnl Synopsis:
dnl PAC_C_MEMATOMIC
dnl
dnl Notes:
dnl Defines names of the following form
dnl + HAVE_GCC_ASM_AND_X86_{MFENCE,LFENCE,SFENCE} - gcc __asm__ will issue
dnl mfence, lfence, or sfence
dnl . HAVE___ASM_AND_X86_{MFENCE,LFENCE,SFENCE} - __asm _emit will issue
dnl mfence, lfence, or sfence
dnl . HAVE_ASM_AND_X86_{MFENCE,LFENCE,SFENCE} - asm("...") will issue
dnl mfence, lfence, or sfence
dnl . HAVE__INTERLOCKEDEXCHANGE - _InterlockedExchange intrinsic is available
dnl (IA64)
dnl . HAVE_GCC_ASM_SPARC_MEMBAR - gcc __asm__ will issue SPARC architecture
dnl memory barrier instruction
dnl . HAVE_SOLARIS_ASM_SPARC_MEMBAR - Solaris asm() will issue SPARC
dnl architecture memory barrier instruction
dnl . HAVE_GCC_ASM_SPARC_STBAR - gcc __asm__ will issue stbar
dnl - HAVE_SOLARIS_ASM_SPARC_STBAR - Solaris __asm() will issue stbar
dnl
dnl D*/
AC_DEFUN([PAC_C_MEMATOMIC],[
AC_CACHE_CHECK([for x86 mfence instruction using __asm__],
pac_cv_have_gcc_asm_and_x86_mfence,[
AC_TRY_RUN([
int main(int argc, char **argv)
{
__asm__ __volatile__ ( ".byte 0x0f, 0xae, 0xf0" ::: "memory" );
exit(0);
}
],
pac_cv_have_gcc_asm_and_x86_mfence=yes,pac_cv_have_gcc_asm_and_x86_mfence=no)])
if test "$pac_cv_have_gcc_asm_and_x86_mfence" = "yes" ; then
AC_DEFINE(HAVE_GCC_ASM_AND_X86_MFENCE, 1, [Define if using gcc on a x86 system with the mfence instruction])
fi
AC_CACHE_CHECK([for x86 sfence instruction using __asm__],
pac_cv_have_gcc_asm_and_x86_sfence,[
AC_TRY_RUN([
int main(int argc, char **argv)
{
__asm__ __volatile__ ( ".byte 0x0f, 0xae, 0xf8" ::: "memory" );
exit(0);
}
],
pac_cv_have_gcc_asm_and_x86_sfence=yes,pac_cv_have_gcc_asm_and_x86_sfence=no)])
if test "$pac_cv_have_gcc_asm_and_x86_sfence" = "yes" ; then
AC_DEFINE(HAVE_GCC_ASM_AND_X86_SFENCE, 1, [Define if using gcc on a x86 system with the sfence instruction])
fi
AC_CACHE_CHECK([for x86 lfence instruction using __asm__],
pac_cv_have_gcc_asm_and_x86_lfence,[
AC_TRY_RUN([
int main(int argc, char **argv)
{
__asm__ __volatile__ ( ".byte 0x0f, 0xae, 0xe8" ::: "memory" );
exit(0);
}
],
pac_cv_have_gcc_asm_and_x86_lfence=yes,pac_cv_have_gcc_asm_and_x86_lfence=no)])
if test "$pac_cv_have_gcc_asm_and_x86_lfence" = "yes" ; then
AC_DEFINE(HAVE_GCC_ASM_AND_X86_LFENCE, 1, [Define if using gcc on a x86 system with the lfence instruction])
fi
dnl Some compilers, like icc, may want __asm _emit
AC_CACHE_CHECK([for x86 mfence instruction using __asm],
pac_cv_have___asm_and_x86_mfence,[
AC_TRY_RUN([
int main(int argc, char **argv)
{
__asm _emit 0x0f __asm _emit 0xae __asm _emit 0xf0 ;
exit(0);
}
],
pac_cv_have___asm_and_x86_mfence=yes,pac_cv_have___asm_and_x86_mfence=no)])
if test "$pac_cv_have___asm_and_x86_mfence" = "yes" ; then
AC_DEFINE(HAVE___ASM_AND_X86_MFENCE, 1, [Define if using __asm on a x86 system with the mfence instruction])
fi
AC_CACHE_CHECK([for x86 sfence instruction using __asm],
pac_cv_have___asm_and_x86_sfence,[
AC_TRY_RUN([
int main(int argc, char **argv)
{
__asm sfence ;
exit(0);
}
],
pac_cv_have___asm_and_x86_sfence=yes,pac_cv_have___asm_and_x86_sfence=no)])
if test "$pac_cv_have___asm_and_x86_sfence" = "yes" ; then
AC_DEFINE(HAVE___ASM_AND_X86_SFENCE, 1, [Define if using __asm on a x86 system with the sfence instruction])
fi
AC_CACHE_CHECK([for x86 lfence instruction using __asm],
pac_cv_have___asm_and_x86_lfence,[
AC_TRY_RUN([
int main(int argc, char **argv)
{
__asm _emit 0x0f __asm _emit 0xae __asm _emit 0xe8 ;
exit(0);
}
],
pac_cv_have___asm_and_x86_lfence=yes,pac_cv_have___asm_and_x86_lfence=no)])
if test "$lac_cv_have___asm_and_x86_lfence" = "yes" ; then
AC_DEFINE(HAVE___ASM_AND_X86_LFENCE, 1, [Define if using __asm on a x86 system with the lfence instruction])
fi
dnl
dnl Some compilers, such as pgcc, may require additional arguments.
dnl pgcc may need -Masmkeyword flag. We may want to try this with and
dnl without adding -Masmkeyword to CFLAGS
AC_CACHE_CHECK([for x86 mfence instruction using asm()],
pac_cv_have_asm_and_x86_mfence,[
AC_TRY_RUN([
int main(int argc, char **argv)
{
asm("_emit 0x0f __asm _emit 0xae __asm _emit 0xf0");
exit(0);
}
],
pac_cv_have_asm_and_x86_mfence=yes,pac_cv_have_asm_and_x86_mfence=no)])
if test "$pac_cv_have_asm_and_x86_mfence" = "yes" ; then
AC_DEFINE(HAVE_ASM_AND_X86_MFENCE, 1, [Define if using asm() on a x86 system with the mfence instruction])
fi
AC_CACHE_CHECK([for x86 sfence instruction using asm()],
pac_cv_have_asm_and_x86_sfence,[
AC_TRY_RUN([
int main(int argc, char **argv)
{
asm("sfence");
exit(0);
}
],
pac_cv_have_asm_and_x86_sfence=yes,pac_cv_have_asm_and_x86_sfence=no)])
if test "$pac_cv_have_asm_and_x86_sfence" = "yes" ; then
AC_DEFINE(HAVE_ASM_AND_X86_SFENCE, 1, [Define if using asm() on a x86 system with the sfence instruction])
fi
AC_CACHE_CHECK([for x86 lfence instruction using asm()],
pac_cv_have_asm_and_x86_lfence,[
AC_TRY_RUN([
int main(int argc, char **argv)
{
asm("_emit 0x0f __asm _emit 0xae __asm _emit 0xe8");
exit(0);
}
],
pac_cv_have_asm_and_x86_lfence=yes,pac_cv_have_asm_and_x86_lfence=no)])
if test "$pac_cv_have_asm_and_x86_lfence" = "yes" ; then
AC_DEFINE(HAVE_ASM_AND_X86_LFENCE, 1, [Define if using asm() on a x86 system with the lfence instruction])
fi
AC_CACHE_CHECK([for _InterlockedExchange intrinsic],
pac_cv_have__InterlockedExchange,[
AC_TRY_RUN([
int main(int argc, char **argv)
{
unsigned long lock, *lock_ptr;
lock_ptr = &lock;
_InterlockedExchange(lock_ptr, 1);
exit(0);
}
],
pac_cv_have__InterlockedExchange=yes,pac_cv_have__InterlockedExchange=no)])
if test "$pac_cv_have__InterlockedExchange" = "yes" ; then
AC_DEFINE(HAVE__INTERLOCKEDEXCHANGE, 1, [Define if _InterlockedExchange intrinsic is available])
fi
AC_CACHE_CHECK([for SPARC membar instruction with gcc],
pac_cv_gcc_sparc_membar,[
AC_TRY_RUN([
int main(int argc, char **argv){
__asm__ __volatile__ ( "membar #StoreLoad | #StoreStore" : : : "memory" );
exit(0);
}],pac_cv_gcc_sparc_membar=yes,pac_cv_gcc_sparc_membar=no)])
if test "$pac_cv_gcc_sparc_membar" = yes ; then
AC_DEFINE(HAVE_GCC_ASM_SPARC_MEMBAR,1,[Define if gcc asm membar supported])
fi
AC_CACHE_CHECK([for SPARC membar instruction with Solaris C],
pac_cv_solaris_sparc_membar,[
AC_TRY_RUN([
int main(int argc, char **argv){
__asm ( "membar #StoreLoad | #StoreStore");
exit(0);
}],pac_cv_solaris_sparc_membar=yes,pac_cv_solaris_sparc_membar=no)])
if test "$pac_cv_solaris_sparc_membar" = yes ; then
AC_DEFINE(HAVE_SOLARIS_ASM_SPARC_MEMBAR,1,[Define if solaris asm membar supported])
fi
AC_CACHE_CHECK([for SPARC stbar instruction with gcc],
pac_cv_gcc_sparc_stbar,[
AC_TRY_RUN([
int main(int argc, char **argv){
__asm__ __volatile__ ( "stbar" : : : "memory" );
exit(0);
}],pac_cv_gcc_sparc_stbar=yes,pac_cv_gcc_sparc_stbar=no)])
if test "$pac_cv_gcc_sparc_stbar" = yes ; then
AC_DEFINE(HAVE_GCC_ASM_SPARC_STBAR,1,[Define if gcc asm stbar supported])
fi
AC_CACHE_CHECK([for SPARC stbar instruction with Solaris C],
pac_cv_solaris_sparc_stbar,[
AC_TRY_RUN([
int main(int argc, char **argv){
__asm ( "stbar" );
exit(0);
}],pac_cv_solaris_sparc_stbar=yes,pac_cv_solaris_sparc_stbar=no)])
if test "$pac_cv_solaris_sparc_stbar" = yes ; then
AC_DEFINE(HAVE_SOLARIS_ASM_SPARC_STBAR,1,[Define if solaris asm stbar supported])
fi
]) armci-mpi/m4/aclocal_mpi.m4 0000644 0001750 0001750 00000037625 12662706250 015254 0 ustar mbanck mbanck dnl
dnl/*D
dnl PAC_LIB_MPI - Check for MPI library
dnl
dnl Synopsis:
dnl PAC_LIB_MPI([action if found],[action if not found])
dnl
dnl Output Effect:
dnl
dnl Notes:
dnl Currently, only checks for lib mpi and mpi.h. Later, we will add
dnl MPI_Pcontrol prototype (const int or not?).
dnl
dnl Prerequisites:
dnl autoconf version 2.13 (for AC_SEARCH_LIBS)
dnl D*/
dnl Other tests to add:
dnl Version of MPI
dnl MPI-2 I/O?
dnl MPI-2 Spawn?
dnl MPI-2 RMA?
dnl PAC_LIB_MPI([found text],[not found text])
AC_DEFUN([PAC_LIB_MPI],[
dnl Set the prereq to 2.50 to avoid having
AC_PREREQ(2.50)
if test "X$pac_lib_mpi_is_building" != "Xyes" ; then
# Use CC if TESTCC is defined
if test "X$pac_save_level" != "X" ; then
pac_save_TESTCC="${TESTCC}"
pac_save_TESTCPP="${TESTCPP}"
CC="$pac_save_CC"
if test "X$pac_save_CPP" != "X" ; then
CPP="$pac_save_CPP"
fi
fi
# Look for MPILIB first if it is defined
AC_SEARCH_LIBS(MPI_Init,$MPILIB mpi mpich mpich2)
if test "$ac_cv_search_MPI_Init" = "no" ; then
ifelse($2,,
AC_MSG_ERROR([Could not find MPI library]),[$2])
fi
AC_CHECK_HEADER(mpi.h,pac_have_mpi_h="yes",pac_have_mpi_h="no")
if test $pac_have_mpi_h = "no" ; then
ifelse($2,,
AC_MSG_ERROR([Could not find mpi.h include file]),[$2])
fi
if test "X$pac_save_level" != "X" ; then
CC="$pac_save_TESTCC"
CPP="$pac_save_TESTCPP"
fi
fi
ifelse($1,,,[$1])
])
dnl This should also set MPIRUN.
dnl
dnl/*D
dnl PAC_ARG_MPI_TYPES - Add command-line switches for different MPI
dnl environments
dnl
dnl Synopsis:
dnl PAC_ARG_MPI_TYPES([default])
dnl
dnl Output Effects:
dnl Adds the following command line options to configure
dnl+ \-\-with\-mpich[=path] - MPICH. 'path' is the location of MPICH commands
dnl. \-\-with\-ibmmpi - IBM MPI
dnl. \-\-with\-lammpi[=path] - LAM/MPI
dnl. \-\-with\-mpichnt - MPICH NT
dnl- \-\-with\-sgimpi - SGI MPI
dnl If no type is selected, and a default ("mpich", "ibmmpi", or "sgimpi")
dnl is given, that type is used as if '--with-' was given.
dnl
dnl Sets 'CC', 'F77', 'TESTCC', 'TESTF77', and 'MPILIBNAME'. Does `not`
dnl perform an AC_SUBST for these values.
dnl Also sets 'MPIBOOT' and 'MPIUNBOOT'. These are used to specify
dnl programs that may need to be run before and after running MPI programs.
dnl For example, 'MPIBOOT' may start demons necessary to run MPI programs and
dnl 'MPIUNBOOT' will stop those demons.
dnl
dnl The two forms of the compilers are to allow for tests of the compiler
dnl when the MPI version of the compiler creates executables that cannot
dnl be run on the local system (for example, the IBM SP, where executables
dnl created with mpcc will not run locally, but executables created
dnl with xlc may be used to discover properties of the compiler, such as
dnl the size of data types).
dnl
dnl Historical note:
dnl Some common autoconf tests, such as AC_CHECK_SIZEOF, used to require
dnl running a program. But some MPI compilers (often really compilation
dnl scripts) produced programs that could only be run with special commands,
dnl such as a batch submission system. To allow these test programs to be
dnl run, a separate set of compiler variables, TESTCC, TESTF77, etc.,
dnl were defined. However, in later versions of autoconf, it both became
dnl unnecessary to run programs for tests such as AC_CHECK_SIZEOF and
dnl it became necessary to define CC etc. before invoking AC_PROG_CC (and
dnl the othe language compilers), because those commands now do much, much
dnl more than just determining the compiler.
dnl
dnl To address the change, we still define the TESTCC ect. compilers where
dnl possible to allow the use of AC_TRY_RUN when required, but we define
dnl the CC etc variables and do not define ac_cv_prog_CC etc., as these
dnl cause autoconf to skip all of the other initialization code that
dnl AC_PROG_CC etc. runs. Note also that this command must occur before
dnl AC_PROG_CC (or anything that might cause AC_PROG_CC to be invoked).
dnl
dnl See also:
dnl PAC_LANG_PUSH_COMPILERS, PAC_LIB_MPI
dnl D*/
AC_DEFUN([PAC_ARG_MPI_TYPES],[
PAC_ARG_MPI_KNOWN_TYPES
PAC_MPI_FIND_COMPILERS
PAC_MPI_CHECK_MPI_LIB
])
dnl
dnl To keep autoconf from prematurely invoking the compiler check scripts,
dnl we need a command that first sets the compilers and a separate one
dnl that makes any necessary checks for libraries
dnl
AC_DEFUN([PAC_ARG_MPI_KNOWN_TYPES],[
AC_ARG_WITH(mpich,
[--with-mpich=path - Assume that we are building with MPICH],
ac_mpi_type=mpich)
# Allow MPICH2 as well as MPICH
AC_ARG_WITH(mpich2,
[--with-mpich=path - Assume that we are building with MPICH],
ac_mpi_type=mpich)
AC_ARG_WITH(lammpi,
[--with-lammpi=path - Assume that we are building with LAM/MPI],
ac_mpi_type=lammpi)
AC_ARG_WITH(ibmmpi,
[--with-ibmmpi - Use the IBM SP implementation of MPI],
ac_mpi_type=ibmmpi)
AC_ARG_WITH(sgimpi,
[--with-sgimpi - Use the SGI implementation of MPI],
ac_mpi_type=sgimpi)
AC_ARG_WITH(mpichnt,
[--with-mpichnt - Use MPICH for Windows NT ],
ac_mpi_type=mpichnt)
AC_ARG_WITH(mpi,
[--with-mpi=path - Use an MPI implementation with compile scripts mpicc
and mpif77 in path/bin],ac_mpi_type=generic)
if test "X$ac_mpi_type" = "X" ; then
if test "X$1" != "X" ; then
ac_mpi_type=$1
else
ac_mpi_type=unknown
fi
fi
if test "$ac_mpi_type" = "unknown" -a "$pac_lib_mpi_is_building" = "yes" ; then
ac_mpi_type="mpich"
fi
])
AC_DEFUN([PAC_MPI_FIND_COMPILERS],[
# Set defaults
MPIRUN_NP="-np "
MPIEXEC_N="-n "
AC_SUBST(MPIRUN_NP)
AC_SUBST(MPIEXEC_N)
dnl
AC_ARG_VAR([MPIEXEC],[Name and path of mpiexec program])
AC_ARG_VAR([MPIRUN],[Name and path of mpirun program])
AC_ARG_VAR([MPIBOOT],[Name and path of program to run before mpirun])
AC_ARG_VAR([MPIUNBOOT],[Name and path of program to run after all mpirun])
AC_ARG_VAR([MPICC],[Name and absolute path of program used to compile MPI programs in C])
AC_ARG_VAR([MPIF77],[Name and absolute path of program used to compile MPI programs in F77])
AC_ARG_VAR([MPICXX],[Name and absolute path of program used to compile MPI programs in C++])
AC_ARG_VAR([MPIF90],[Name and absolute path of program used to compile MPI programs in F90])
#
# Check for things that will cause trouble. For example,
# if MPICC is defined but does not contain a / or \, then PATH_PROG will
# ignore the value
if test -n "$MPICC" ; then
case $MPICC in
changequote(<<,>>)
[\\/]* | ?:[\\/]*)
changequote([,])
# Ok, PATH_PROG will figure it out
;;
*)
AC_MSG_ERROR([MPICC must be set to an absolute path if it is set])
esac
fi
if test -n "$MPICXX" ; then
case $MPICXX in
changequote(<<,>>)
[\\/]* | ?:[\\/]*)
changequote([,])
# Ok, PATH_PROG will figure it out
;;
*)
AC_MSG_ERROR([MPICXX must be set to an absolute path if it is set])
esac
fi
if test -n "$MPIF77" ; then
case $MPIF77 in
changequote(<<,>>)
[\\/]* | ?:[\\/]*)
changequote([,])
# Ok, PATH_PROG will figure it out
;;
*)
AC_MSG_ERROR([MPIF77 must be set to an absolute path if it is set])
esac
fi
if test -n "$MPIF90" ; then
case $MPIF90 in
changequote(<<,>>)
[\\/]* | ?:[\\/]*)
changequote([,])
# Ok, PATH_PROG will figure it out
;;
*)
AC_MSG_ERROR([MPIF90 must be set to an absolute path if it is set])
esac
fi
case $ac_mpi_type in
mpich)
dnl
dnl This isn't correct. It should try to get the underlying compiler
dnl from the mpicc and mpif77 scripts or mpireconfig
if test "X$pac_lib_mpi_is_building" != "Xyes" ; then
save_PATH="$PATH"
if test "$with_mpich" != "yes" -a "$with_mpich" != "no" ; then
# Look for commands; if not found, try adding bin to the
# path
if test ! -x $with_mpich/mpicc -a -x $with_mpich/bin/mpicc ; then
with_mpich="$with_mpich/bin"
fi
PATH=$with_mpich:${PATH}
fi
AC_PATH_PROG(MPICC,mpicc)
if test -z "$TESTCC" ; then TESTCC=${CC-cc} ; fi
CC="$MPICC"
# Note that autoconf may unconditionally change the value of
# CC (!) in some other command. Thus, we define CCMASTER
CCMASTER=$CC
# to permit configure codes to recover the correct CC. This
# is an ugly not-quite-correct workaround for the fact that
# does not want you to change the C compiler once you have set it
# (But since it does so unconditionally, it silently creates
# bogus output files.)
AC_PATH_PROG(MPIF77,mpif77)
if test -z "$TESTF77" ; then TESTF77=${F77-f77} ; fi
F77="$MPIF77"
AC_PATH_PROG(MPIFC,mpif90)
if test -z "$TESTFC" ; then TESTFC=${FC-f90} ; fi
FC="$MPIFC"
AC_PATH_PROG(MPICXX,mpiCC)
if test -z "$TESTCXX" ; then TESTCXX=${CXX-CC} ; fi
CXX="$MPICXX"
# We may want to restrict this to the path containing mpirun
AC_PATH_PROG(MPIEXEC,mpiexec)
AC_PATH_PROG(MPIRUN,mpirun)
AC_PATH_PROG(MPIBOOT,mpichboot)
AC_PATH_PROG(MPIUNBOOT,mpichstop)
PATH="$save_PATH"
MPILIBNAME="mpich"
else
# All of the above should have been passed in the environment!
:
fi
;;
mpichnt)
;;
lammpi)
dnl
dnl This isn't correct. It should try to get the underlying compiler
dnl from the mpicc and mpif77 scripts or mpireconfig
save_PATH="$PATH"
if test "$with_mpich" != "yes" -a "$with_mpich" != "no" ; then
# Look for commands; if not found, try adding bin to the path
if test ! -x $with_lammpi/mpicc -a -x $with_lammpi/bin/mpicc ; then
with_lammpi="$with_lammpi/bin"
fi
PATH=$with_lammpi:${PATH}
fi
AC_PATH_PROG(MPICC,mpicc)
if test -z "$TESTCC" ; then TESTCC=${CC-cc} ; fi
CC="$MPICC"
AC_PATH_PROG(MPIF77,mpif77)
if test -z "$TESTCC" ; then TESTF77=${F77-f77} ; fi
F77="$MPIF77"
AC_PATH_PROG(MPIFC,mpif90)
TESTFC=${FC-f90}
if test -z "$TESTFC" ; then TESTFC=${FC-f90} ; fi
FC="$MPIFC"
AC_PATH_PROG(MPICXX,mpiCC)
if test -z "$TESTCXX" ; then TESTCXX=${CXX-CC} ; fi
CXX="$MPICXX"
PATH="$save_PATH"
MPILIBNAME="lammpi"
MPIBOOT="lamboot"
MPIUNBOOT="wipe"
MPIRUN="mpirun"
;;
ibmmpi)
AC_CHECK_PROGS(MPCC,mpcc)
AC_CHECK_PROGS(MPXLF,mpxlf)
if test -z "$MPCC" -o -z "$MPXLF" ; then
AC_MSG_ERROR([Could not find IBM MPI compilation scripts. Either mpcc or mpxlf is missing])
fi
if test -z "$TESTCC" ; then TESTCC=${CC-xlC} ; fi
if test -z "$TESTF77" ; then TESTF77=${F77-xlf}; fi
CC=mpcc; F77=mpxlf
# There is no mpxlf90, but the options langlvl and free can
# select the Fortran 90 version of xlf
if test "$enable_f90" != no ; then
AC_CHECK_PROGS(MPIXLF90,mpxlf90)
if test -z "$TESTFC" ; then TESTFC=${FC-xlf90}; fi
if test "X$MPIXLF90" != "X" ; then
FC="mpxlf90"
else
FC="mpxlf -qlanglvl=90ext -qfree=f90"
fi
fi
MPILIBNAME=""
cross_compiling=yes
# Turn off the autoconf version 3 warning message
ac_tool_warned=yes
;;
sgimpi)
if test -z "$TESTCC" ; then TESTCC=${CC:=cc} ; fi
if test -z "$TESTF77" ; then TESTF77=${F77:=f77} ; fi
if test -z "$TESTCXX" ; then TESTCXX=${CXX:=CC} ; fi
if test -z "$TESTFC" ; then TESTFC=${FC:=f90} ; fi
AC_CHECK_LIB(mpi,MPI_Init)
if test "$ac_cv_lib_mpi_MPI_Init" = "yes" ; then
MPILIBNAME="mpi"
fi
MPIRUN=mpirun
MPIBOOT=""
MPIUNBOOT=""
;;
generic)
# Find the compilers. Expect the compilers to be mpicc and mpif77
# in $with_mpi/bin
PAC_PROG_CC
# We only look for the other compilers if there is no
# disable for them
if test "$enable_f77" != no -a "$enable_fortran" != no ; then
AC_PROG_F77
fi
if test "$enable_cxx" != no ; then
AC_PROG_CXX
fi
if test "$enable_f90" != no ; then
PAC_PROG_FC
fi
# Set defaults for the TEST versions if not already set
if test -z "$TESTCC" ; then
TESTCC=${CC:=cc}
fi
if test -z "$TESTF77" ; then
TESTF77=${F77:=f77}
fi
if test -z "$TESTCXX" ; then
TESTCXX=${CXX:=CC}
fi
if test -z "$TESTFC" ; then
TESTFC=${FC:=f90}
fi
# in $with_mpi/bin or $with_mpi
if test "X$MPICC" = "X" ; then
if test -x "$with_mpi/bin/mpicc" ; then
MPICC=$with_mpi/bin/mpicc
elif test -x "$with_mpi/mpicc" ; then
MPICC=$with_mpi/mpicc
fi
fi
if test "X$MPICXX" = "X" ; then
if test -x "$with_mpi/bin/mpicxx" ; then
MPICXX=$with_mpi/bin/mpicxx
elif test -x "$with_mpi/mpicxx" ; then
MPICXX=$with_mpi/mpicxx
fi
fi
if test "X$MPIF77" = "X" ; then
if test -x "$with_mpi/bin/mpif77" ; then
MPIF77=$with_mpi/bin/mpif77
elif test -x "$with_mpi/mpif77" ; then
MPIF77=$with_mpi/mpif77
fi
fi
if test "X$MPIF90" = "X" ; then
if test -x "$with_mpi/bin/mpif90" ; then
MPIF90=$with_mpi/bin/mpif90
elif test -x "$with_mpi/mpif90" ; then
MPIF90=$with_mpi/mpif90
fi
fi
if test "X$MPIEXEC" = "X" ; then
if test -x "$with_mpi/bin/mpiexec" ; then
MPIEXEC=$with_mpi/bin/mpiexec
elif test -x "$with_mpi/mpiexec" ; then
MPIEXEC=$with_mpi/mpiexec
fi
fi
CC=$MPICC
F77=$MPIF77
if test "X$MPICXX" != "X" ; then CXX=$MPICXX ; fi
if test "X$MPIF90" != "X" ; then F90=$MPIF90 ; fi
;;
*)
# Use the default choices for the compilers
;;
esac
# Tell autoconf to determine properties of the compilers (these are the
# compilers for MPI programs)
AC_PROG_CC
if test "$enable_f77" != no -a "$enable_fortran" != no ; then
AC_PROG_F77
fi
if test "$enable_cxx" != no ; then
AC_PROG_CXX
fi
if test "$enable_f90" != no ; then
PAC_PROG_FC
fi
])
dnl
dnl This uses the selected CC etc to check for include paths and libraries
AC_DEFUN([PAC_MPI_CHECK_MPI_LIB],[
case $ac_mpi_type in
mpich)
;;
mpichnt)
dnl
dnl This isn't adequate, but it helps with using MPICH-NT/SDK.gcc
save_CFLAGS="$CFLAGS"
CFLAGS="$save_CFLAGS -I$with_mpichnt/include"
save_CPPFLAGS="$CPPFLAGS"
CPPFLAGS="$save_CPPFLAGS -I$with_mpichnt/include"
save_LDFLAGS="$LDFLAGS"
LDFLAGS="$save_LDFLAGS -L$with_mpichnt/lib"
AC_CHECK_LIB(mpich,MPI_Init,found="yes",found="no")
if test "$found" = "no" ; then
AC_CHECK_LIB(mpich2,MPI_Init,found="yes",found="no")
fi
if test "$enable_cxx" != no ; then
AC_PROG_CXX
fi
if test "$enable_f90" != no ; then
PAC_PROG_FC
fi
# Set defaults for the TEST versions if not already set
if test -z "$TESTCC" ; then TESTCC=${CC:=cc} ; fi
if test -z "$TESTF77" ; then TESTF77=${F77:=f77} ; fi
if test -z "$TESTCXX" ; then TESTCXX=${CXX:=CC} ; fi
if test -z "$TESTFC" ; then TESTFC=${FC:=f90} ; fi
if test "$found" = "no" ; then
CFLAGS=$save_CFLAGS
CPPFLAGS=$save_CPPFLAGS
LDFLAGS=$save_LDFLAGS
fi
;;
lammpi)
;;
ibmmpi)
;;
sgimpi)
AC_CHECK_LIB(mpi,MPI_Init)
if test "$ac_cv_lib_mpi_MPI_Init" = "yes" ; then
MPILIBNAME="mpi"
fi
;;
generic)
AC_SEARCH_LIBS(MPI_Init,mpi mpich2 mpich)
if test "$ac_cv_lib_mpi_MPI_Init" = "yes" ; then
MPILIBNAME="mpi"
fi
;;
*)
;;
esac
])
dnl
dnl/*D
dnl PAC_MPI_F2C - Determine if MPI has the MPI-2 functions MPI_xxx_f2c and
dnl MPI_xxx_c2f
dnl
dnl Output Effect:
dnl Define 'HAVE_MPI_F2C' if the routines are found.
dnl
dnl Notes:
dnl Looks only for 'MPI_Request_c2f'.
dnl D*/
AC_DEFUN([PAC_MPI_F2C],[
AC_CACHE_CHECK([for MPI F2C and C2F routines],
pac_cv_mpi_f2c,
[
AC_TRY_LINK([#include "mpi.h"],
[MPI_Request request;MPI_Fint a;a = MPI_Request_c2f(request);],
pac_cv_mpi_f2c="yes",pac_cv_mpi_f2c="no")
])
if test "$pac_cv_mpi_f2c" = "yes" ; then
AC_DEFINE(HAVE_MPI_F2C,1,[Define if MPI has F2C])
fi
])
dnl
dnl/*D
dnl PAC_HAVE_ROMIO - make mpi.h include mpio.h if romio enabled
dnl
dnl Output Effect:
dnl expands @HAVE_ROMIO@ in mpi.h into #include "mpio.h"
dnl D*/
AC_DEFUN([PAC_HAVE_ROMIO],[
if test "$enable_romio" = "yes" ; then HAVE_ROMIO='#include "mpio.h"'; fi
AC_SUBST(HAVE_ROMIO)
])
armci-mpi/m4/aclocal_libs.m4 0000644 0001750 0001750 00000004424 12662706250 015407 0 ustar mbanck mbanck
dnl PAC_SET_HEADER_LIB_PATH(with_option)
dnl This macro looks for the --with-xxx=, --with-xxx-include and --with-xxx-lib=
dnl options and sets the library and include paths.
AC_DEFUN([PAC_SET_HEADER_LIB_PATH],[
AC_ARG_WITH($1,
AC_HELP_STRING([--with-$1=path],
[specify path where $1 include directory and lib directory can be found]),
if test "${with_$1}" != "yes" -a "${with_$1}" != "no" ; then
# is adding lib64 by default really the right thing to do? What if
# we are on a 32-bit host that happens to have both lib dirs available?
LDFLAGS="$LDFLAGS -L${with_$1}/lib64 -L${with_$1}/lib"
CPPFLAGS="$CPPFLAGS -I${with_$1}/include"
WRAPPER_CFLAGS="$WRAPPER_CFLAGS -I${with_$1}/include"
fi,
)
AC_ARG_WITH($1-include,
AC_HELP_STRING([--with-$1-include=path],
[specify path where $1 include directory can be found]),
if test "${with_$1_include}" != "yes" -a "${with_$1_include}" != "no" ; then
CPPFLAGS="$CPPFLAGS -I${with_$1_include}"
WRAPPER_CFLAGS="$WRAPPER_CFLAGS -I${with_$1_include}"
fi,
)
AC_ARG_WITH($1-lib,
AC_HELP_STRING([--with-$1-lib=path],
[specify path where $1 lib directory can be found]),
if test "${with_$1_lib}" != "yes" -a "${with_$1_lib}" != "no" ; then
LDFLAGS="$LDFLAGS -L${with_$1_lib}"
fi,
)
])
dnl PAC_CHECK_HEADER_LIB(with_option, header.h, libname, function, action-if-yes, action-if-no)
dnl This macro checks for a header and lib. It is assumed that the
dnl user can specify a path to the includes and libs using --with-xxx=.
dnl The xxx is specified in the "with_option" parameter.
AC_DEFUN([PAC_CHECK_HEADER_LIB],[
failure=no
AC_CHECK_HEADER([$2],,failure=yes)
AC_CHECK_LIB($3,$4,,failure=yes)
if test "$failure" = "no" ; then
$5
else
$6
fi
])
dnl PAC_CHECK_HEADER_LIB_FATAL(with_option, header.h, libname, function)
dnl Similar to PAC_CHECK_HEADER_LIB, but errors out on failure
AC_DEFUN([PAC_CHECK_HEADER_LIB_FATAL],[
PAC_CHECK_HEADER_LIB($1,$2,$3,$4,success=yes,success=no)
if test "$success" = "no" ; then
AC_MSG_ERROR(['$2 or lib$3 library not found. Did you specify --with-$1= or --with-$1-include= or --with-$1-lib=?'])
fi
])
armci-mpi/m4/aclocal_runlog.m4 0000644 0001750 0001750 00000003507 12662706250 015765 0 ustar mbanck mbanck dnl
dnl PAC_RUN_LOG mimics _AC_RUN_LOG which is autoconf internal routine.
dnl We also make sure PAC_RUN_LOG can be used in AS_IF, so the last
dnl test command should have terminating ]), i.e. without newline before ]).
dnl
AC_DEFUN([PAC_RUNLOG],[
{ AS_ECHO(["$as_me:$LINENO: $1"]) >&AS_MESSAGE_LOG_FD
(eval $1) 2>&AS_MESSAGE_LOG_FD
ac_status=$?
AS_ECHO(["$as_me:$LINENO: \$? = $ac_status"]) >&AS_MESSAGE_LOG_FD
test $ac_status = 0; }])
dnl
dnl PAC_COMMAND_IFELSE is written to replace AC_TRY_EVAL with added logging
dnl to config.log, i.e. AC_TRY_EVAL does not log anything to config.log.
dnl If autoconf provides AC_COMMAND_IFELSE or AC_EVAL_IFELSE,
dnl AC_COMMAND_IFELSE dnl should be replaced by the official autoconf macros.
dnl
dnl PAC_COMMAND_IFELSE(COMMMAND,[ACTION-IF-RUN-OK],[ACTION-IF-RUN-FAIL])
dnl
AC_DEFUN([PAC_COMMAND_IFELSE],[
dnl Should use _AC_DO_TOKENS but use AC_RUN_LOG instead
dnl because _AC_XX is autoconf's undocumented macro.
AS_IF([PAC_RUNLOG([$1])],[
$2
],[
AS_ECHO(["$as_me: program exited with status $ac_status"]) >&AS_MESSAGE_LOG_FD
m4_ifvaln([$3],[
(exit $ac_status)
$3
])
])
])
dnl
dnl
dnl
AC_DEFUN([PAC_EVAL_IFELSE],[
dnl Should use _AC_DO_TOKENS but use AC_RUN_LOG instead
dnl because _AC_XX is autoconf's undocumented macro.
AS_IF([PAC_RUNLOG([$$1])],[
$2
],[
AS_ECHO(["$as_me: program exited with status $ac_status"]) >&AS_MESSAGE_LOG_FD
m4_ifvaln([$3],[
(exit $ac_status)
$3
])
])
])
dnl
dnl
dnl
AC_DEFUN([PAC_RUNLOG_IFELSE],[
dnl pac_TESTLOG is the internal temporary logfile for this macro.
pac_TESTLOG="pac_test.log"
rm -f $pac_TESTLOG
PAC_COMMAND_IFELSE([$1 > $pac_TESTLOG],[
ifelse([$2],[],[],[$2])
],[
AS_ECHO(["*** $1 :"]) >&AS_MESSAGE_LOG_FD
cat $pac_TESTLOG >&AS_MESSAGE_LOG_FD
ifelse([$3],[],[],[$3])
])
rm -f $pac_TESTLOG
])
armci-mpi/m4/CHECKOUT 0000644 0001750 0001750 00000000136 12662706250 013662 0 ustar mbanck mbanck This is a snapshot checkout of
https://svn.mcs.anl.gov/repos/mpi/mpich2/trunk revision r7341.
armci-mpi/m4/aclocal_util.m4 0000644 0001750 0001750 00000013101 12662706250 015423 0 ustar mbanck mbanck dnl Nesting safe macros for saving variables
dnl Usage: PAC_PUSH_FLAG(CFLAGS)
AC_DEFUN([PAC_PUSH_FLAG],[
if test -z "${pac_save_$1_nesting}" ; then
pac_save_$1_nesting=0
fi
eval pac_save_$1_${pac_save_$1_nesting}='"$$1"'
pac_save_$1_nesting=`expr ${pac_save_$1_nesting} + 1`
])
dnl Usage: PAC_POP_FLAG(CFLAGS)
AC_DEFUN([PAC_POP_FLAG],[
pac_save_$1_nesting=`expr ${pac_save_$1_nesting} - 1`
eval $1="\$pac_save_$1_${pac_save_$1_nesting}"
eval pac_save_$1_${pac_save_$1_nesting}=""
])
dnl Usage: PAC_PUSH_ALL_FLAGS
AC_DEFUN([PAC_PUSH_ALL_FLAGS],[
PAC_PUSH_FLAG(CFLAGS)
PAC_PUSH_FLAG(CPPFLAGS)
PAC_PUSH_FLAG(CXXFLAGS)
PAC_PUSH_FLAG(FFLAGS)
PAC_PUSH_FLAG(FCFLAGS)
PAC_PUSH_FLAG(LDFLAGS)
PAC_PUSH_FLAG(LIBS)
])
dnl Usage: PAC_POP_ALL_FLAGS
AC_DEFUN([PAC_POP_ALL_FLAGS],[
PAC_POP_FLAG(CFLAGS)
PAC_POP_FLAG(CPPFLAGS)
PAC_POP_FLAG(CXXFLAGS)
PAC_POP_FLAG(FFLAGS)
PAC_POP_FLAG(FCFLAGS)
PAC_POP_FLAG(LDFLAGS)
PAC_POP_FLAG(LIBS)
])
dnl PAC_PREFIX_FLAG - Save flag with a prefix
dnl Usage: PAC_PREFIX_FLAG(PREFIX, FLAG)
AC_DEFUN([PAC_PREFIX_FLAG],[
$1_$2=$$2
export $1_$2
AC_SUBST($1_$2)
])
dnl PAC_PREFIX_ALL_FLAGS - Save flags with a prefix
dnl Usage: PAC_PREFIX_ALL_FLAGS(PREFIX)
AC_DEFUN([PAC_PREFIX_ALL_FLAGS],[
PAC_PREFIX_FLAG($1, CFLAGS)
PAC_PREFIX_FLAG($1, CPPFLAGS)
PAC_PREFIX_FLAG($1, CXXFLAGS)
PAC_PREFIX_FLAG($1, FFLAGS)
PAC_PREFIX_FLAG($1, FCFLAGS)
PAC_PREFIX_FLAG($1, LDFLAGS)
PAC_PREFIX_FLAG($1, LIBS)
])
dnl Usage: PAC_APPEND_FLAG([-02], [CFLAGS])
dnl appends the given argument to the specified shell variable unless the
dnl argument is already present in the variable
AC_DEFUN([PAC_APPEND_FLAG],[
AC_REQUIRE([AC_PROG_FGREP])
AS_IF(
[echo "$$2" | $FGREP -e '$1' >/dev/null 2>&1],
[echo "$2(='$$2') contains '$1', not appending" >&AS_MESSAGE_LOG_FD],
[echo "$2(='$$2') does not contain '$1', appending" >&AS_MESSAGE_LOG_FD
$2="$$2 $1"]
)
])
dnl Usage: PAC_PREPEND_FLAG([-lpthread], [LIBS])
dnl Prepends the given argument to the specified shell variable unless the
dnl argument is already present in the variable.
dnl
dnl This is typically used for LIBS and similar variables because libraries
dnl should be added in reverse order.
AC_DEFUN([PAC_PREPEND_FLAG],[
AC_REQUIRE([AC_PROG_FGREP])
AS_IF(
[echo "$$2" | $FGREP -e '$1' >/dev/null 2>&1],
[echo "$2(='$$2') contains '$1', not prepending" >&AS_MESSAGE_LOG_FD],
[echo "$2(='$$2') does not contain '$1', prepending" >&AS_MESSAGE_LOG_FD
$2="$1 $$2"]
)
])
dnl PAC_MKDIRS(path)
dnl Create any missing directories in the path
AC_DEFUN([PAC_MKDIRS],[
# Build any intermediate directories
for dir in $1 ; do
saveIFS="$IFS"
IFS="/"
tmp_curdir=""
for tmp_subdir in $dir ; do
tmp_curdir="${tmp_curdir}$tmp_subdir"
if test ! -d "$tmp_curdir" ; then mkdir "$tmp_curdir" ; fi
tmp_curdir="${tmp_curdir}/"
done
IFS="$saveIFS"
done
])
# Find something to use for mkdir -p. Eventually, this will have a
# script for backup. As of autoconf-2.63, AC_PROG_MKDIR_P was broken;
# it was checking to see if it recognized the "version" of mkdir and
# was deciding based on that. This should always be a feature test.
AC_DEFUN([PAC_PROG_MKDIR_P],[
AC_CACHE_CHECK([whether mkdir -p works],
pac_cv_mkdir_p,[
pac_cv_mkdir_p=no
rm -rf .tmp
if mkdir -p .tmp/.foo 1>/dev/null 2>&1 ; then
if test -d .tmp/.foo ; then
pac_cv_mkdir_p=yes
fi
fi
rm -rf .tmp
])
if test "$pac_cv_mkdir_p" = "yes" ; then
MKDIR_P="mkdir -p"
export MKDIR_P
else
AC_MSG_WARN([mkdir -p does not work; the install step may fail])
fi
AC_SUBST(MKDIR_P)
])
dnl Test for a clean VPATH directory. Provide this command with the names
dnl of all of the generated files that might cause problems
dnl (Makefiles won't cause problems because there's no VPATH usage for them)
dnl
dnl Synopsis
dnl PAC_VPATH_CHECK([file-names],[directory-names])
dnl file-names should be files other than config.status and any header (e.g.,
dnl fooconf.h) file that should be removed. It is optional
AC_DEFUN([PAC_VPATH_CHECK],[
# This is needed for Mac OSX 10.5
rm -rf conftest.dSYM
rm -f conftest*
date >conftest$$
# If creating a file in the current directory does not show up in the srcdir
# then we're doing a VPATH build (or something is very wrong)
if test ! -s $srcdir/conftest$$ ; then
pac_dirtyfiles=""
pac_dirtydirs=""
pac_header=""
ifdef([AC_LIST_HEADER],[pac_header=AC_LIST_HEADER])
for file in config.status $pac_header $1 ; do
if test -f $srcdir/$file ; then
pac_dirtyfiles="$pac_dirtyfiles $file"
fi
done
ifelse($2,,,[
for dir in $2 ; do
if test -d $srcdir/$dir ; then
pac_dirtydirs="$pac_dirtydirs $dir"
fi
done
])
if test -n "$pac_dirtyfiles" -o -n "$pac_dirtydirs" ; then
# Create a nice message about what to remove
rmmsg=""
if test -n "$pac_dirtyfiles" ; then
rmmsg="files $pac_dirtyfiles"
fi
if test -n "$pac_dirtydirs" ; then
if test -n "$rmmsg" ; then
rmmsg="$rmmsg and directories $pac_dirtydirs"
else
rmmsg="directories $pac_dirtydirs"
fi
fi
if test -f $srcdir/Makefile ; then
AC_MSG_ERROR([You cannot do a VPATH build if the source directory has been
configured. Run "make distclean" in $srcdir first and make sure that the
$rmmsg have been removed.])
else
AC_MSG_ERROR([You cannot do a VPATH build if the source directory has been
configured. Remove the $rmmsg in $srcdir.])
fi
fi
fi
# This is needed for Mac OSX 10.5
rm -rf conftest.dSYM
rm -f conftest*
])
armci-mpi/m4/aclocal_f77.m4 0000644 0001750 0001750 00000152672 12662706250 015072 0 ustar mbanck mbanck dnl PAC_PROG_F77 - reprioritize the F77 compiler search order
AC_DEFUN([PAC_PROG_F77],[
PAC_PUSH_FLAG([FFLAGS])
AC_PROG_F77([ifort pgf77 af77 xlf frt cf77 fort77 fl32 fort ifc efc ftn gfortran f77 g77])
PAC_POP_FLAG([FFLAGS])
])
dnl
dnl/*D
dnl PAC_PROG_F77_NAME_MANGLE - Determine how the Fortran compiler mangles
dnl names
dnl
dnl Synopsis:
dnl PAC_PROG_F77_NAME_MANGLE([action])
dnl
dnl Output Effect:
dnl If no action is specified, one of the following names is defined:
dnl.vb
dnl If fortran names are mapped:
dnl lower -> lower F77_NAME_LOWER
dnl lower -> lower_ F77_NAME_LOWER_USCORE
dnl lower -> UPPER F77_NAME_UPPER
dnl lower_lower -> lower__ F77_NAME_LOWER_2USCORE
dnl mixed -> mixed F77_NAME_MIXED
dnl mixed -> mixed_ F77_NAME_MIXED_USCORE
dnl mixed -> UPPER@STACK_SIZE F77_NAME_UPPER_STDCALL
dnl.ve
dnl If an action is specified, it is executed instead.
dnl
dnl Notes:
dnl We assume that if lower -> lower (any underscore), upper -> upper with the
dnl same underscore behavior. Previous versions did this by
dnl compiling a Fortran program and running strings -a over it. Depending on
dnl strings is a bad idea, so instead we try compiling and linking with a
dnl C program, since that is why we are doing this anyway. A similar approach
dnl is used by FFTW, though without some of the cases we check (specifically,
dnl mixed name mangling). STD_CALL not only specifies a particular name
dnl mangling convention (adding the size of the calling stack into the function
dnl name, but also the stack management convention (callee cleans the stack,
dnl and arguments are pushed onto the stack from right to left)
dnl
dnl One additional problem is that some Fortran implementations include
dnl references to the runtime (like pgf90_compiled for the pgf90 compiler
dnl used as the "Fortran 77" compiler). This is not yet solved.
dnl
dnl D*/
dnl
AC_DEFUN([PAC_PROG_F77_NAME_MANGLE],[
AC_CACHE_CHECK([for Fortran 77 name mangling],
pac_cv_prog_f77_name_mangle,
[
# Check for strange behavior of Fortran. For example, some FreeBSD
# systems use f2c to implement f77, and the version of f2c that they
# use generates TWO (!!!) trailing underscores
# Currently, WDEF is not used but could be...
#
# Eventually, we want to be able to override the choices here and
# force a particular form. This is particularly useful in systems
# where a Fortran compiler option is used to force a particular
# external name format (rs6000 xlf, for example).
# This is needed for Mac OSX 10.5
rm -rf conftest.dSYM
rm -f conftest*
cat > conftest.f <&AC_FD_CC
cat conftest.f >&AC_FD_CC
fi
AC_LANG_SAVE
AC_LANG_C
save_LIBS="$LIBS"
dnl FLIBS comes from AC_F77_LIBRARY_LDFLAGS
LIBS="fconftestf.o $FLIBS $LIBS"
AC_TRY_LINK([extern void my_name(int);],my_name(0);,pac_cv_prog_f77_name_mangle="lower")
if test "X$pac_cv_prog_f77_name_mangle" = "X" ; then
AC_TRY_LINK([extern void my_name_(int);],my_name_(0);,pac_cv_prog_f77_name_mangle="lower underscore")
fi
if test "X$pac_cv_prog_f77_name_mangle" = "X" ; then
AC_TRY_LINK([void __stdcall MY_NAME(int);],MY_NAME(0);,pac_cv_prog_f77_name_mangle="upper stdcall")
fi
if test "X$pac_cv_prog_f77_name_mangle" = "X" ; then
AC_TRY_LINK([extern void MY_NAME(int);],MY_NAME(0);,pac_cv_prog_f77_name_mangle="upper")
fi
if test "X$pac_cv_prog_f77_name_mangle" = "X" ; then
AC_TRY_LINK([extern void my_name__(int);],my_name__(0);,
pac_cv_prog_f77_name_mangle="lower doubleunderscore")
fi
if test "X$pac_cv_prog_f77_name_mangle" = "X" ; then
AC_TRY_LINK([extern void MY_name(int);],MY_name(0);,pac_cv_prog_f77_name_mangle="mixed")
fi
if test "X$pac_cv_prog_f77_name_mangle" = "X" ; then
AC_TRY_LINK([extern void MY_name_(int);],MY_name_(0);,pac_cv_prog_f77_name_mangle="mixed underscore")
fi
LIBS="$save_LIBS"
AC_LANG_RESTORE
# If we got to this point, it may be that the programs have to be
# linked with the Fortran, not the C, compiler. Try reversing
# the language used for the test
dnl Note that the definition of AC_TRY_LINK and AC_LANG_PROGRAM
dnl is broken in autoconf and will generate spurious warning messages
dnl To fix this, we use
dnl AC _LINK_IFELSE([AC _LANG_PROGRAM(,[[body]])],action-if-true)
dnl instead of AC _TRY_LINK(,body,action-if-true)
if test "X$pac_cv_prog_f77_name_mangle" = "X" ; then
AC_LANG_SAVE
AC_LANG_FORTRAN77
save_LIBS="$LIBS"
LIBS="conftestc.o $LIBS"
if test "X$ac_ccompile" = "X" ; then
ac_ccompile='${CC-cc} -c $CFLAGS conftest.c 1>&AC_FD_CC'
fi
# This is needed for Mac OSX 10.5
rm -rf conftest.dSYM
rm -f conftest*
cat > conftest.c <&AC_FD_CC
cat conftest.c >&AC_FD_CC
fi
AC_LINK_IFELSE([AC_LANG_PROGRAM(,[[ call my_name(0)]])],
pac_cv_prog_f77_name_mangle="lower")
if test "X$pac_cv_prog_f77_name_mangle" = "X" ; then
# This is needed for Mac OSX 10.5
rm -rf conftest.dSYM
rm -f conftest*
cat > conftest.c <&AC_FD_CC
cat conftest.c >&AC_FD_CC
fi
AC_LINK_IFELSE([AC_LANG_PROGRAM(,[[ call my_name(0)]])],
pac_cv_prog_f77_name_mangle="lower underscore")
fi
if test "X$pac_cv_prog_f77_name_mangle" = "X" ; then
# This is needed for Mac OSX 10.5
rm -rf conftest.dSYM
rm -f conftest*
cat >conftest.c <&AC_FD_CC
cat conftest.c >&AC_FD_CC
fi
AC_LINK_IFELSE([AC_LANG_PROGRAM(,[[ call my_name(0)]])],
pac_cv_prog_f77_name_mangle="upper stdcall")
fi
if test "X$pac_cv_prog_f77_name_mangle" = "X" ; then
# This is needed for Mac OSX 10.5
rm -rf conftest.dSYM
rm -f conftest*
cat >conftest.c <&AC_FD_CC
cat conftest.c >&AC_FD_CC
fi
AC_LINK_IFELSE([AC_LANG_PROGRAM(,[[ call MY_NAME(0)]])],
pac_cv_prog_f77_name_mangle="upper")
fi
if test "X$pac_cv_prog_f77_name_mangle" = "X" ; then
# This is needed for Mac OSX 10.5
rm -rf conftest.dSYM
rm -f conftest*
cat >conftest.c <&AC_FD_CC
cat conftest.c >&AC_FD_CC
fi
AC_LINK_IFELSE([AC_LANG_PROGRAM(,[[ call my_name(0)]])],
pac_cv_prog_f77_name_mangle="lower doubleunderscore")
fi
if test "X$pac_cv_prog_f77_name_mangle" = "X" ; then
# This is needed for Mac OSX 10.5
rm -rf conftest.dSYM
rm -f conftest*
cat >conftest.c <&AC_FD_CC
cat conftest.c >&AC_FD_CC
fi
AC_LINK_IFELSE([AC_LANG_PROGRAM(,[[ call MY_name(0)]])],
pac_cv_prog_f77_name_mangle="mixed")
fi
if test "X$pac_cv_prog_f77_name_mangle" = "X" ; then
# This is needed for Mac OSX 10.5
rm -rf conftest.dSYM
rm -f conftest*
cat >conftest.c <&AC_FD_CC
cat conftest.c >&AC_FD_CC
fi
AC_LINK_IFELSE([AC_LANG_PROGRAM(,[[ call MY_name(0)]])],
pac_cv_prog_f77_name_mangle="mixed underscore")
fi
LIBS="$save_LIBS"
AC_LANG_RESTORE
fi
# This is needed for Mac OSX 10.5
rm -rf conftest.dSYM
rm -f fconftest*
])
# Make the actual definition
pac_namecheck=`echo X$pac_cv_prog_f77_name_mangle | sed 's/ /-/g'`
ifelse([$1],,[
pac_cv_test_stdcall=""
case $pac_namecheck in
X) AC_MSG_WARN([Cannot determine Fortran naming scheme]) ;;
Xlower) AC_DEFINE(F77_NAME_LOWER,1,[Define if Fortran names are lowercase])
F77_NAME_MANGLE="F77_NAME_LOWER"
;;
Xlower-underscore) AC_DEFINE(F77_NAME_LOWER_USCORE,1,[Define if Fortran names are lowercase with a trailing underscore])
F77_NAME_MANGLE="F77_NAME_LOWER_USCORE"
;;
Xlower-doubleunderscore) AC_DEFINE(F77_NAME_LOWER_2USCORE,1,[Define if Fortran names containing an underscore have two trailing underscores])
F77_NAME_MANGLE="F77_NAME_LOWER_2USCORE"
;;
Xupper) AC_DEFINE(F77_NAME_UPPER,1,[Define if Fortran names are uppercase])
F77_NAME_MANGLE="F77_NAME_UPPER"
;;
Xmixed) AC_DEFINE(F77_NAME_MIXED,1,[Define if Fortran names preserve the original case])
F77_NAME_MANGLE="F77_NAME_MIXED"
;;
Xmixed-underscore) AC_DEFINE(F77_NAME_MIXED_USCORE,1,[Define if Fortran names preserve the original case and add a trailing underscore])
F77_NAME_MANGLE="F77_NAME_MIXED_USCORE"
;;
Xupper-stdcall) AC_DEFINE(F77_NAME_UPPER,1,[Define if Fortran names are uppercase])
F77_NAME_MANGLE="F77_NAME_UPPER_STDCALL"
pac_cv_test_stdcall="__stdcall"
;;
*) AC_MSG_WARN([Unknown Fortran naming scheme]) ;;
esac
AC_SUBST(F77_NAME_MANGLE)
# Get the standard call definition
# FIXME: This should use F77_STDCALL, not STDCALL (non-conforming name)
if test "X$pac_cv_test_stdcall" = "X" ; then
F77_STDCALL=""
else
F77_STDCALL="__stdcall"
fi
#
AC_DEFINE_UNQUOTED(STDCALL,$F77_STDCALL,[Define calling convention])
],[$1])
])
dnl
dnl/*D
dnl PAC_PROG_F77_CHECK_SIZEOF - Determine the size in bytes of a Fortran
dnl type
dnl
dnl Synopsis:
dnl PAC_PROG_F77_CHECK_SIZEOF(type,[cross-size])
dnl
dnl Output Effect:
dnl Sets SIZEOF_F77_uctype to the size if bytes of type.
dnl If type is unknown, the size is set to 0.
dnl If cross-compiling, the value cross-size is used (it may be a variable)
dnl For example 'PAC_PROG_F77_CHECK_SIZEOF(real)' defines
dnl 'SIZEOF_F77_REAL' to 4 on most systems. The variable
dnl 'pac_cv_sizeof_f77_' (e.g., 'pac_cv_sizeof_f77_real') is also set to
dnl the size of the type.
dnl If the corresponding variable is already set, that value is used.
dnl If the name has an '*' in it (e.g., 'integer*4'), the defined name
dnl replaces that with an underscore (e.g., 'SIZEOF_F77_INTEGER_4').
dnl
dnl Notes:
dnl If the 'cross-size' argument is not given, 'autoconf' will issue an error
dnl message. You can use '0' to specify undetermined.
dnl
dnl D*/
AC_DEFUN([PAC_PROG_F77_CHECK_SIZEOF],[
changequote(<<, >>)dnl
dnl The name to #define.
dnl If the arg value contains a variable, we need to update that
define(<>, translit(sizeof_f77_$1, [a-z *], [A-Z__]))dnl
dnl The cache variable name.
define(<>, translit(pac_cv_f77_sizeof_$1, [ *], [__]))dnl
changequote([, ])dnl
AC_CACHE_CHECK([for size of Fortran type $1],PAC_CV_NAME,[
AC_REQUIRE([PAC_PROG_F77_NAME_MANGLE])
# This is needed for Mac OSX 10.5
rm -rf conftest.dSYM
rm -f conftest*
cat < conftest.f
subroutine isize( )
$1 i(2)
call cisize( i(1), i(2) )
end
EOF
if test "X$ac_fcompile" = "X" ; then
ac_fcompile='${F77-f77} -c $FFLAGS conftest.f 1>&AC_FD_CC'
fi
if AC_TRY_EVAL(ac_fcompile) && test -s conftest.o ; then
mv conftest.o conftestf.o
AC_LANG_SAVE
AC_LANG_C
save_LIBS="$LIBS"
dnl Add the Fortran linking libraries
LIBS="conftestf.o $FLIBS $LIBS"
AC_TRY_RUN([#include
#ifdef F77_NAME_UPPER
#define cisize_ CISIZE
#define isize_ ISIZE
#elif defined(F77_NAME_LOWER) || defined(F77_NAME_MIXED)
#define cisize_ cisize
#define isize_ isize
#endif
static int isize_val=0;
void cisize_(char *,char*);
void isize_(void);
void cisize_(char *i1p, char *i2p)
{
isize_val = (int)(i2p - i1p);
}
int main(int argc, char **argv)
{
FILE *f = fopen("conftestval", "w");
if (!f) return 1;
isize_();
fprintf(f,"%d\n", isize_val );
return 0;
}], eval PAC_CV_NAME=`cat conftestval`,eval PAC_CV_NAME=0,
ifelse([$2],,,eval PAC_CV_NAME=$2))
# Problem. If the process fails to run, then there won't be
# a good error message. For example, with one Portland Group
# installation, we had problems with finding the libpgc.so shared library
# The autoconf code for TRY_RUN doesn't capture the output from
# the test program (!)
LIBS="$save_LIBS"
AC_LANG_RESTORE
else
echo "configure: failed program was:" >&AC_FD_CC
cat conftest.f >&AC_FD_CC
ifelse([$2],,eval PAC_CV_NAME=0,eval PAC_CV_NAME=$2)
fi
])
AC_DEFINE_UNQUOTED(PAC_TYPE_NAME,$PAC_CV_NAME,[Define size of PAC_TYPE_NAME])
undefine([PAC_TYPE_NAME])
undefine([PAC_CV_NAME])
])
dnl
dnl This version uses a Fortran program to link programs.
dnl This is necessary because some compilers provide shared libraries
dnl that are not within the default linker paths (e.g., our installation
dnl of the Portland Group compilers)
dnl
AC_DEFUN([PAC_PROG_F77_CHECK_SIZEOF_EXT],[
changequote(<<,>>)dnl
dnl The name to #define.
dnl If the arg value contains a variable, we need to update that
define(<>, translit(sizeof_f77_$1, [a-z *], [A-Z__]))dnl
dnl The cache variable name.
define(<>, translit(pac_cv_f77_sizeof_$1, [ *], [__]))dnl
changequote([,])dnl
AC_CACHE_CHECK([for size of Fortran type $1],PAC_CV_NAME,[
AC_REQUIRE([PAC_PROG_F77_NAME_MANGLE])
if test "$cross_compiling" = yes ; then
ifelse([$2],,[AC_MSG_WARN([No value provided for size of $1 when cross-compiling])]
,eval PAC_CV_NAME=$2)
else
# This is needed for Mac OSX 10.5
rm -rf conftest.dSYM
rm -f conftest*
cat < conftestc.c
#include
#include "confdefs.h"
#ifdef F77_NAME_UPPER
#define cisize_ CISIZE
#define isize_ ISIZE
#elif defined(F77_NAME_LOWER) || defined(F77_NAME_MIXED)
#define cisize_ cisize
#define isize_ isize
#endif
int cisize_(char *,char*);
int cisize_(char *i1p, char *i2p)
{
int isize_val=0;
FILE *f = fopen("conftestval", "w");
if (!f) return 1;
isize_val = (int)(i2p - i1p);
fprintf(f,"%d\n", isize_val );
fclose(f);
return 0;
}
EOF
pac_tmp_compile='$CC -c $CFLAGS $CPPFLAGS conftestc.c >&5'
if AC_TRY_EVAL(pac_tmp_compile) && test -s conftestc.o ; then
AC_LANG_SAVE
AC_LANG_FORTRAN77
saveLIBS=$LIBS
LIBS="conftestc.o $LIBS"
dnl TRY_RUN does not work correctly for autoconf 2.13 (the
dnl macro includes C-preprocessor directives that are not
dnl valid in Fortran. Instead, we do this by hand
cat >conftest.f <conftest2.f <conftest.f </dev/null 2>&1 ; then
AC_MSG_RESULT(yes)
AC_MSG_CHECKING([whether routines compiled with $1 can be linked with ones compiled without $1])
rm -f conftest2.out
rm -f conftest.bas
ac_fscompile3='${F77-f77} -c $save_FFLAGS conftest2.f >conftest2.out 2>&1'
ac_fscompilelink4='${F77-f77} $FFLAGS -o conftest conftest2.o conftest.f $LDFLAGS >conftest.bas 2>&1'
if AC_TRY_EVAL(ac_fscompile3) && test -s conftest2.o ; then
if AC_TRY_EVAL(ac_fscompilelink4) && test -x conftest ; then
if diff -b conftest.out conftest.bas >/dev/null 2>&1 ; then
ac_result="yes"
else
echo "configure: Compiler output differed in two cases" >&AC_FD_CC
diff -b conftest.out conftest.bas >&AC_FD_CC
fi
else
echo "configure: failed program was:" >&AC_FD_CC
cat conftest.f >&AC_FD_CC
fi
else
echo "configure: failed program was:" >&AC_FD_CC
cat conftest2.f >&AC_FD_CC
fi
else
# diff
echo "configure: Compiler output differed in two cases" >&AC_FD_CC
diff -b conftest.out conftest.bas >&AC_FD_CC
fi
else
# try_eval(fscompilelink2)
echo "configure: failed program was:" >&AC_FD_CC
cat conftest.f >&AC_FD_CC
fi
if test "$ac_result" != "yes" -a -s conftest.out ; then
cat conftest.out >&AC_FD_CC
fi
else
# Could not compile without the option!
echo "configure: Could not compile program" >&AC_FD_CC
cat conftest.f >&AC_FD_CC
cat conftest.bas >&AC_FD_CC
fi
# Restore FFLAGS before 2nd/3rd argument commands are executed,
# as 2nd/3rd argument command could be modifying FFLAGS.
FFLAGS="$save_FFLAGS"
if test "$ac_result" = "yes" ; then
AC_MSG_RESULT(yes)
ifelse($2,,FOPTIONS="$FOPTIONS $1",$2)
else
AC_MSG_RESULT(no)
$3
fi
# This is needed for Mac OSX 10.5
rm -rf conftest.dSYM
rm -f conftest*
])
dnl/*D
dnl PAC_PROG_F77_CMDARGS - Determine how to access the command line from
dnl Fortran 77
dnl
dnl Output Effects:
dnl The following variables are set:
dnl.vb
dnl F77_GETARG - Statement to get an argument i into string s
dnl F77_IARGC - Routine to return the number of arguments
dnl FXX_MODULE - Module command when using Fortran 90 compiler
dnl F77_GETARGDECL - Declaration of routine used for F77_GETARG
dnl F77_GETARG_FFLAGS - Flags needed when compiling/linking
dnl F77_GETARG_LDFLAGS - Flags needed when linking
dnl.ve
dnl If 'F77_GETARG' has a value, then that value and the values for these
dnl other symbols will be used instead. If no approach is found, all of these
dnl variables will have empty values.
dnl If no other approach works and a file 'f77argdef' is in the directory,
dnl that file will be sourced for the values of the above four variables.
dnl
dnl In most cases, you should add F77_GETARG_FFLAGS to the FFLAGS variable
dnl and F77_GETARG_LDFLAGS to the LDFLAGS variable, to ensure that tests are
dnl performed on the compiler version that will be used.
dnl
dnl 'AC_SUBST' is called for all six variables.
dnl
dnl One complication is that on systems with multiple Fortran compilers,
dnl some libraries used by one Fortran compiler may have been (mis)placed
dnl in a common location. We have had trouble with libg2c in particular.
dnl To work around this, we test whether iargc etc. work first. This
dnl will catch most systems and will speed up the tests.
dnl
dnl Next, the libraries are only added if they are needed to complete a
dnl link; they aren''t added just because they exist.
dnl
dnl f77argdef
dnl D*/
dnl
dnl Random notes
dnl You can export the command line arguments from C to the g77 compiler
dnl using
dnl extern char **__libc_argv;
dnl extern int __libc_argc;
dnl f_setarg( __libc_argc, __libc_argv );
dnl
AC_DEFUN([PAC_PROG_F77_CMDARGS],[
found_cached="yes"
AC_MSG_CHECKING([for routines to access the command line from Fortran 77])
AC_CACHE_VAL(pac_cv_prog_f77_cmdarg,
[
AC_MSG_RESULT([searching...])
found_cached="no"
# First, we perform a quick check. Does iargc and getarg work?
fxx_module="${FXX_MODULE:-}"
f77_getargdecl="${F77_GETARGDECL:-external getarg}"
f77_getarg="${F77_GETARG:-call GETARG(i,s)}"
f77_iargc="${F77_IARGC:-IARGC()}"
#
# Grumble. The Absoft Fortran compiler computes i - i as 0 and then
# 1.0 / 0 at compile time, even though the code may never be executed.
# What we need is a way to generate an error, so the second usage of i
# was replaced with f77_iargc.
cat > conftest.f </dev/null 2>&1 ; then
found_answer="yes"
FXX_MODULE="$fxx_module"
F77_GETARGDECL="$f77_getargdecl"
F77_GETARG="$f77_getarg"
F77_IARGC="$f77_iargc"
AC_MSG_RESULT(yes)
fi
fi
fi
if test $found_answer = "no" ; then
AC_MSG_RESULT(no)
# Grumph. Here are a bunch of different approaches
# We have several axes the check:
# Library to link with (none, -lU77 (HPUX), -lg2c (LINUX f77))
# PEPCF90 (Intel ifc)
# The first line is a dummy
# (we experimented with using a , but this caused other
# problems because we need in the IFS)
trial_LIBS="0 -lU77 -lPEPCF90"
if test "$NOG2C" != "1" ; then
trial_LIBS="$trial_LIBS -lg2c"
fi
# Discard libs that are not availble:
save_IFS="$IFS"
# Make sure that IFS includes a space, or the tests that run programs
# may fail
IFS=" ""
"
save_trial_LIBS="$trial_LIBS"
trial_LIBS=""
cat > conftest.f <, the space is important
# To make the Absoft f77 and f90 work together, we need to prefer the
# upper case versions of the arguments. They also require libU77.
# -YCFRL=1 causes Absoft f90 to work with g77 and similar (f2c-based)
# Fortran compilers
#
# Problem: The Intel efc compiler hangs when presented with -N109 .
# The only real fix for this is to detect this compiler and exclude
# the test. We may want to reorganize these tests so that if we
# can compile code without special options, we never look for them.
#
using_intel_efc="no"
pac_test_msg=`$F77 -V 2>&1 | grep 'Intel(R) Fortran Itanium'`
if test "$pac_test_msg" != "" ; then
using_intel_efc="yes"
fi
if test "$using_intel_efc" = "yes" ; then
trial_FLAGS="000"
else
trial_FLAGS="000
-N109
-f
-YEXT_NAMES=UCS
-YEXT_NAMES=LCS
-YCFRL=1
+U77"
fi
# Discard options that are not available:
# (IFS already saved above)
IFS=" ""
"
save_trial_FLAGS="$trial_FLAGS"
trial_FLAGS=""
for flag in $save_trial_FLAGS ; do
if test "$flag" = " " -o "$flag" = "000" ; then
opt_ok="yes"
else
PAC_F77_CHECK_COMPILER_OPTION($flag,opt_ok=yes,opt_ok=no)
fi
if test "$opt_ok" = "yes" ; then
if test "$flag" = " " -o "$flag" = "000" ; then
fflag=""
else
fflag="$flag"
fi
# discard options that don't allow mixed-case name matching
cat > conftest.f < conftest.f </dev/null 2>&1 ; then
found_answer="yes"
fi
else
found_answer="yes"
fi
fi
IFS=" ""
"
if test "$found_answer" = "yes" ; then
AC_MSG_RESULT([yes])
pac_cv_prog_f77_cmdarg="$MSG"
pac_cv_prog_f77_cmdarg_fflags="$flags"
pac_cv_prog_f77_cmdarg_ldflags="$libs"
break
else
AC_MSG_RESULT([no])
echo "configure: failed program was:" >&AC_FD_CC
cat conftest.f >&AC_FD_CC
fi
done
done
IFS="$save_IFS"
rm -f conftest.*
trial=`expr $trial + 1`
done
fi
pac_cv_F77_GETARGDECL="$F77_GETARGDECL"
pac_cv_F77_IARGC="$F77_IARGC"
pac_cv_F77_GETARG="$F77_GETARG"
pac_cv_FXX_MODULE="$FXX_MODULE"
])
if test "$found_cached" = "yes" ; then
AC_MSG_RESULT([$pac_cv_prog_f77_cmdarg])
elif test -z "$pac_cv_F77_IARGC" ; then
AC_MSG_WARN([Could not find a way to access the command line from Fortran 77])
fi
# Set the variable values based on pac_cv_prog_xxx
F77_GETARGDECL="$pac_cv_F77_GETARGDECL"
F77_IARGC="$pac_cv_F77_IARGC"
F77_GETARG="$pac_cv_F77_GETARG"
FXX_MODULE="$pac_cv_FXX_MODULE"
F77_GETARG_FFLAGS="$pac_cv_prog_f77_cmdarg_fflags"
F77_GETARG_LDFLAGS="$pac_cv_prog_f77_cmdarg_ldflags"
AC_SUBST(F77_GETARGDECL)
AC_SUBST(F77_IARGC)
AC_SUBST(F77_GETARG)
AC_SUBST(FXX_MODULE)
AC_SUBST(F77_GETARG_FFLAGS)
AC_SUBST(F77_GETARG_LDFLAGS)
])
dnl/*D
dnl PAC_PROG_F77_LIBRARY_DIR_FLAG - Determine the flag used to indicate
dnl the directories to find libraries in
dnl
dnl Notes:
dnl Many compilers accept '-Ldir' just like most C compilers.
dnl Unfortunately, some (such as some HPUX Fortran compilers) do not,
dnl and require instead either '-Wl,-L,dir' or something else. This
dnl command attempts to determine what is accepted. The flag is
dnl placed into 'F77_LIBDIR_LEADER'.
dnl
dnl D*/
dnl
dnl An earlier version of this only tried the arguments without using
dnl a library. This failed when the HP compiler complained about the
dnl arguments, but produced an executable anyway.
AC_DEFUN([PAC_PROG_F77_LIBRARY_DIR_FLAG],[
if test "X$F77_LIBDIR_LEADER" = "X" ; then
AC_CACHE_CHECK([for Fortran 77 flag for library directories],
pac_cv_prog_f77_library_dir_flag,
[
rm -f conftest.* conftest1.*
cat > conftest.f < conftest1.f <&AC_FD_CC
cat conftest1.f >&AC_FD_CC
fi
# This is needed for Mac OSX 10.5
rm -rf conftest.dSYM
rm -f conftest*
])
AC_SUBST(F77_LIBDIR_LEADER)
if test "X$pac_cv_prog_f77_library_dir_flag" != "X" ; then
F77_LIBDIR_LEADER="$pac_cv_prog_f77_library_dir_flag"
fi
fi
])
dnl/*D
dnl PAC_PROG_F77_HAS_INCDIR - Check whether Fortran accepts -Idir flag
dnl
dnl Syntax:
dnl PAC_PROG_F77_HAS_INCDIR(directory,action-if-true,action-if-false)
dnl
dnl Output Effect:
dnl Sets 'F77_INCDIR' to the flag used to choose the directory.
dnl
dnl Notes:
dnl This refers to the handling of the common Fortran include extension,
dnl not to the use of '#include' with the C preprocessor.
dnl If directory does not exist, it will be created. In that case, the
dnl directory should be a direct descendant of the current directory.
dnl
dnl D*/
AC_DEFUN([PAC_PROG_F77_HAS_INCDIR],[
checkdir=$1
AC_CACHE_CHECK([for include directory flag for Fortran],
pac_cv_prog_f77_has_incdir,[
if test ! -d $checkdir ; then mkdir $checkdir ; fi
cat >$checkdir/conftestf.h <conftest.f < conftest.$ac_ext <&AC_FD_CC
cat conftest.$ac_ext >&AC_FD_CC
# This is needed for Mac OSX 10.5
rm -rf conftest.dSYM
rm -rf conftest*
pac_cv_prog_f77_allows_unused_externals="no"
$4
fi
# This is needed for Mac OSX 10.5
rm -rf conftest.dSYM
rm -f conftest*
#
AC_LANG_RESTORE
])
if test "X$pac_cv_prog_f77_allows_unused_externals" = "Xyes" ; then
ifelse([$1],,:,[$1])
else
ifelse([$2],,:,[$2])
fi
])
dnl /*D
dnl PAC_PROG_F77_HAS_POINTER - Determine if Fortran allows pointer type
dnl
dnl Synopsis:
dnl PAC_PROG_F77_HAS_POINTER(action-if-true,action-if-false)
dnl D*/
AC_DEFUN([PAC_PROG_F77_HAS_POINTER],[
AC_CACHE_CHECK([whether Fortran has pointer declaration],
pac_cv_prog_f77_has_pointer,[
AC_LANG_SAVE
AC_LANG_FORTRAN77
AC_COMPILE_IFELSE([AC_LANG_PROGRAM(,[
integer M
pointer (MPTR,M)
data MPTR/0/
])],
pac_cv_prog_f77_has_pointer="yes",
pac_cv_prog_f77_has_pointer="no")
AC_LANG_RESTORE
])
if test "$pac_cv_prog_f77_has_pointer" = "yes" ; then
ifelse([$1],,:,[$1])
else
ifelse([$2],,:,[$2])
fi
])
dnl pac_prog_f77_run_proc_from_c( c main program, fortran routine,
dnl action-if-works, action-if-fails,
dnl cross-action )
dnl Fortran routine MUST be named ftest unless you include code
dnl to select the appropriate Fortran name.
dnl
AC_DEFUN([PAC_PROG_F77_RUN_PROC_FROM_C],[
# This is needed for Mac OSX 10.5
rm -rf conftest.dSYM
rm -f conftest*
cat < conftest.f
$2
EOF
dnl
if test "X$ac_fcompile" = "X" ; then
ac_fcompile='${F77-f77} -c $FFLAGS conftest.f 1>&AC_FD_CC'
fi
if AC_TRY_EVAL(ac_fcompile) && test -s conftest.o ; then
mv conftest.o conftestf.o
AC_LANG_SAVE
AC_LANG_C
save_LIBS="$LIBS"
LIBS="conftestf.o $FLIBS $LIBS"
AC_TRY_RUN([#include
#ifdef F77_NAME_UPPER
#define ftest_ FTEST
#elif defined(F77_NAME_LOWER) || defined(F77_NAME_MIXED)
#define ftest_ ftest
#endif
$1
], [$3], [$4], [$5] )
LIBS="$save_LIBS"
AC_LANG_RESTORE
else
echo "configure: failed program was:" >&AC_FD_CC
cat conftest.f >&AC_FD_CC
fi
# This is needed for Mac OSX 10.5
rm -rf conftest.dSYM
rm -f conftest*
])
dnl PAC_PROG_F77_IN_C_LIBS
dnl
dnl Find the essential libraries that are needed to use the C linker to
dnl create a program that includes a trival Fortran code.
dnl
dnl For example, all pgf90 compiled objects include a reference to the
dnl symbol pgf90_compiled, found in libpgf90 .
dnl
dnl There is an additional problem. To *run* programs, we may need
dnl additional arguments; e.g., if shared libraries are used. Even
dnl with autoconf 2.52, the autoconf macro to find the library arguments
dnl doesn't handle this, either by detecting the use of -rpath or
dnl by trying to *run* a trivial program. It only checks for *linking*.
dnl
dnl
AC_DEFUN([PAC_PROG_F77_IN_C_LIBS],[
AC_MSG_CHECKING([for which Fortran libraries are needed to link C with Fortran])
F77_IN_C_LIBS="$FLIBS"
# This is needed for Mac OSX 10.5
rm -rf conftest.dSYM
rm -f conftest*
cat < conftest.f
subroutine ftest
end
EOF
dnl
if test "X$ac_fcompile" = "X" ; then
ac_fcompile='${F77-f77} -c $FFLAGS conftest.f 1>&AC_FD_CC'
fi
if AC_TRY_EVAL(ac_fcompile) && test -s conftest.o ; then
mv conftest.o mconftestf.o
AC_LANG_SAVE
AC_LANG_C
save_LIBS="$LIBS"
dnl First try with no libraries
LIBS="mconftestf.o $save_LIBS"
AC_TRY_LINK([#include ],[
#ifdef F77_NAME_UPPER
#define ftest_ FTEST
#elif defined(F77_NAME_LOWER) || defined(F77_NAME_MIXED)
#define ftest_ ftest
#endif
extern void ftest_(void);
ftest_();
], [link_worked=yes], [link_worked=no] )
if test "$link_worked" = "no" ; then
flibdirs=`echo $FLIBS | tr ' ' '\012' | grep '\-L' | tr '\012' ' '`
fliblibs=`echo $FLIBS | tr ' ' '\012' | grep -v '\-L' | tr '\012' ' '`
for flibs in $fliblibs ; do
LIBS="mconftestf.o $flibdirs $flibs $save_LIBS"
AC_TRY_LINK([#include ],[
#ifdef F77_NAME_UPPER
#define ftest_ FTEST
#elif defined(F77_NAME_LOWER) || defined(F77_NAME_MIXED)
#define ftest_ ftest
#endif
extern void ftest_(void);
ftest_();
], [link_worked=yes], [link_worked=no] )
if test "$link_worked" = "yes" ; then
F77_IN_C_LIBS="$flibdirs $flibs"
break
fi
done
if test "$link_worked" = "no" ; then
# try to add libraries until it works...
flibscat=""
for flibs in $fliblibs ; do
flibscat="$flibscat $flibs"
LIBS="mconftestf.o $flibdirs $flibscat $save_LIBS"
AC_TRY_LINK([#include ],[
#ifdef F77_NAME_UPPER
#define ftest_ FTEST
#elif defined(F77_NAME_LOWER) || defined(F77_NAME_MIXED)
#define ftest_ ftest
#endif
extern void ftest_(void);
ftest_();
], [link_worked=yes], [link_worked=no] )
if test "$link_worked" = "yes" ; then
F77_IN_C_LIBS="$flibdirs $flibscat"
break
fi
done
fi
else
# No libraries needed
F77_IN_C_LIBS=""
fi
LIBS="$save_LIBS"
AC_LANG_RESTORE
else
echo "configure: failed program was:" >&AC_FD_CC
cat conftest.f >&AC_FD_CC
fi
# This is needed for Mac OSX 10.5
rm -rf conftest.dSYM
rm -f conftest* mconftest*
if test -z "$F77_IN_C_LIBS" ; then
AC_MSG_RESULT(none)
else
AC_MSG_RESULT($F77_IN_C_LIBS)
fi
])
dnl Test to see if we should use C or Fortran to link programs whose
dnl main program is in Fortran. We may find that neither work because
dnl we need special libraries in each case.
dnl
AC_DEFUN([PAC_PROG_F77_LINKER_WITH_C],[
AC_LANG_SAVE
AC_LANG_C
AC_TRY_COMPILE(,
long long a;,AC_DEFINE(HAVE_LONG_LONG,1,[Define if long long allowed]))
AC_MSG_CHECKING([for linker for Fortran main programs])
dnl
dnl Create a program that uses multiplication and division in case
dnl that requires special libraries
cat > conftest.c < conftest.f <&AC_FD_CC ; then
AC_MSG_RESULT([Use Fortran to link programs])
elif ${CC} ${CFLAGS} -o conftest conftest.o conftest1.o $LDFLAGS $FLIBS 2>&AC_FD_CC ; then
AC_MSG_RESULT([Use C with FLIBS to link programs])
F77LINKER="$CC"
F77_LDFLAGS="$F77_LDFLAGS $FLIBS"
else
AC_MSG_RESULT([Unable to determine how to link Fortran programs with C])
fi
else
AC_MSG_ERROR([Could not compile Fortran test program])
fi
AC_LANG_RESTORE
])
dnl Check to see if a C program can be linked when using the libraries
dnl needed by C programs
dnl
AC_DEFUN([PAC_PROG_F77_CHECK_FLIBS],
[AC_MSG_CHECKING([whether C can link with $FLIBS])
# Try to link a C program with all of these libraries
save_LIBS="$LIBS"
LIBS="$LIBS $FLIBS"
AC_TRY_LINK(,[int a;],runs=yes,runs=no)
LIBS="$save_LIBS"
AC_MSG_RESULT($runs)
if test "$runs" = "no" ; then
AC_MSG_CHECKING([for which libraries can be used])
pac_ldirs=""
pac_libs=""
pac_other=""
for name in $FLIBS ; do
case $name in
-l*) pac_libs="$pac_libs $name" ;;
-L*) pac_ldirs="$pac_ldirs $name" ;;
*) pac_other="$pac_other $name" ;;
esac
done
save_LIBS="$LIBS"
keep_libs=""
for name in $pac_libs ; do
LIBS="$save_LIBS $pac_ldirs $pac_other $name"
AC_TRY_LINK(,[int a;],runs=yes,runs=no)
if test $runs = "yes" ; then keep_libs="$keep_libs $name" ; fi
done
AC_MSG_RESULT($keep_libs)
LIBS="$save_LIBS"
FLIBS="$pac_ldirs $pac_other $keep_libs"
fi
])
dnl Test for extra libraries needed when linking C routines that use
dnl stdio with Fortran. This test was created for OSX, which
dnl sometimes requires -lSystemStubs. If another library is needed,
dnl add it to F77_OTHER_LIBS
AC_DEFUN([PAC_PROG_F77_AND_C_STDIO_LIBS],[
# To simply the code in the cache_check macro, chose the routine name
# first, in case we need it
confname=conf1_
case "$pac_cv_prog_f77_name_mangle" in
"lower underscore") confname=conf1_ ;;
"upper stdcall") confname=CONF1 ;;
upper) confname=CONF1 ;;
"lower doubleunderscore") confname=conf1_ ;;
lower) confname=conf1 ;;
"mixed underscore") confname=conf1_ ;;
mixed) confname=conf1 ;;
esac
AC_CACHE_CHECK([what libraries are needed to link Fortran programs with C routines that use stdio],pac_cv_prog_f77_and_c_stdio_libs,[
pac_cv_prog_f77_and_c_stdio_libs=unknown
# This is needed for Mac OSX 10.5
rm -rf conftest.dSYM
rm -f conftest*
cat >conftest.f <conftestc.c <
int $confname( int a )
{ printf( "The answer is %d\n", a ); fflush(stdout); return 0; }
EOF
tmpcmd='${CC-cc} -c $CFLAGS conftestc.c 1>&AC_FD_CC'
if AC_TRY_EVAL(tmpcmd) && test -s conftestc.o ; then
:
else
echo "configure: failed program was:" >&AC_FD_CC
cat conftestc.c >&AC_FD_CC
fi
tmpcmd='${F77-f77} $FFLAGS -o conftest conftest.f conftestc.o 1>&AC_FD_CC'
if AC_TRY_EVAL(tmpcmd) && test -x conftest ; then
pac_cv_prog_f77_and_c_stdio_libs=none
else
# Try again with -lSystemStubs
tmpcmd='${F77-f77} $FFLAGS -o conftest conftest.f conftestc.o -lSystemStubs 1>&AC_FD_CC'
if AC_TRY_EVAL(tmpcmd) && test -x conftest ; then
pac_cv_prog_f77_and_c_stdio_libs="-lSystemStubs"
else
echo "configure: failed program was:" >&AC_FD_CC
cat conftestc.c >&AC_FD_CC
echo "configure: with Fortran 77 program:" >&AC_FD_CC
cat conftest.f >&AC_FD_CC
fi
fi
# This is needed for Mac OSX 10.5
rm -rf conftest.dSYM
rm -f conftest*
])
if test "$pac_cv_prog_f77_and_c_stdio_libs" != none -a \
"$pac_cv_prog_f77_and_c_stdio_libs" != unknown ; then
F77_OTHER_LIBS="$F77_OTHER_LIBS $pac_cv_prog_f77_and_c_stdio_libs"
fi
])
dnl Check that the FLIBS determined by AC_F77_LIBRARY_LDFLAGS is valid.
dnl That macro (at least as of autoconf 2.59) attempted to parse the output
dnl of the compiler when asked to be verbose; in the case of the Fujitsu
dnl frt Fortran compiler, it included files that frt looked for and then
dnl discarded because they did not exist.
AC_DEFUN([PAC_PROG_F77_FLIBS_VALID],[
pac_cv_f77_flibs_valid=unknown
AC_MSG_CHECKING([whether $F77 accepts the FLIBS found by autoconf])
AC_LANG_SAVE
AC_LANG_FORTRAN77
dnl We can't use TRY_LINK, because it wants a routine name, not a
dnl declaration. The following is the body of TRY_LINK, slightly modified.
cat > conftest.$ac_ext <&AC_FD_CC
cat conftest.$ac_ext >&AC_FD_CC
pac_cv_f77_flibs_valid=no
fi
AC_MSG_RESULT($pac_cv_f77_flibs_valid)
if test $pac_cv_f77_flibs_valid = no ; then
# See which ones *are* valid
AC_MSG_CHECKING([for valid entries in FLIBS])
goodFLIBS=""
saveFLIBS=$FLIBS
FLIBS=""
for arg in $saveFLIBS ; do
FLIBS="$goodFLIBS $arg"
if AC_TRY_EVAL(ac_link) && test -s conftest${ac_exeext}; then
goodFLIBS=$FLIBS
else
echo "configure: failed program was:" >&AC_FD_CC
cat conftest.$ac_ext >&AC_FD_CC
fi
done
FLIBS=$goodFLIBS
AC_MSG_RESULT($FLIBS)
fi
#
# This is needed for Mac OSX 10.5
rm -rf conftest.dSYM
rm -f conftest*
AC_LANG_RESTORE
])
AC_DEFUN([PAC_PROG_F77_OBJ_LINKS_WITH_C],[
AC_MSG_CHECKING([whether Fortran 77 and C objects are compatible])
dnl
rm -rf conftestc.dSYM
rm -f conftestc*
dnl construct with a C function with all possible F77 name mangling schemes.
cat <<_EOF > conftestc.c
/* lower */
void c_subpgm( int *rc );
void c_subpgm( int *rc ) { *rc = 1; }
/* lower underscore */
void c_subpgm_( int *rc );
void c_subpgm_( int *rc ) { *rc = 2; }
/* upper */
void C_SUBPGM( int *rc );
void C_SUBPGM( int *rc ) { *rc = 3; }
/* lower doubleunderscore */
void c_subpgm__( int *rc );
void c_subpgm__( int *rc ) { *rc = 4; }
/* mixed */
void C_subpgm( int *rc );
void C_subpgm( int *rc ) { *rc = 5; }
/* mixed underscore */
void C_subpgm_( int *rc );
void C_subpgm_( int *rc ) { *rc = 6; }
_EOF
dnl
dnl Compile the C function into object file.
dnl
pac_Ccompile='${CC-cc} -c $CFLAGS conftestc.c 1>&AC_FD_CC'
if AC_TRY_EVAL(pac_Ccompile) && test -s conftestc.${ac_objext} ; then
pac_c_working=yes
else
pac_c_working=no
echo "configure: failed C program was:" >&AC_FD_CC
cat conftestc.c >&AC_FD_CC
fi
dnl
rm -rf conftestf.dSYM
rm -f conftestf*
cat <<_EOF > conftestf.f
program test
integer rc
rc = -1
call c_subpgm( rc )
write(6,*) "rc=", rc
end
_EOF
dnl - compile the fortran program into object file
pac_Fcompile='${F77-f77} -c $FFLAGS conftestf.f 1>&AC_FD_CC'
if AC_TRY_EVAL(pac_Fcompile) && test -s conftestf.${ac_objext} ; then
pac_f77_working=yes
else
pac_f77_working=no
echo "configure: failed F77 program was:" >&AC_FD_CC
cat conftestf.f >&AC_FD_CC
fi
dnl
if test "$pac_c_working" = "yes" -a "$pac_f77_working" = "yes" ; then
dnl Try linking with F77 compiler
rm -f conftest${ac_exeext}
pac_link='$F77 $FFLAGS -o conftest${ac_exeext} conftestf.${ac_objext} conftestc.${ac_objext} $LDFLAGS >&AC_FD_CC'
if AC_TRY_EVAL(pac_link) && test -s conftest${ac_exeext} ; then
AC_MSG_RESULT(yes)
rm -fr conftestf.dSYM conftestc.dSYM conftest.dSYM
rm -f conftest*
else
dnl Try linking with C compiler
rm -f conftest${ac_exeext}
pac_link='$CC $CFLAGS -o conftest${ac_exeext} conftestf.${ac_objext} conftestc.${ac_objext} $LDFLAGS $FLIBS >&AC_FD_CC'
if AC_TRY_EVAL(pac_link) && test -s conftest${ac_exeext} ; then
AC_MSG_RESULT(yes)
rm -fr conftestf.dSYM conftestc.dSYM conftest.dSYM
rm -f conftest*
else
AC_MSG_RESULT(no)
AC_CHECK_PROG(FILE, file, file, [])
if test "X$FILE" != "X" ; then
fobjtype="`${FILE} conftestf.${ac_objext} | sed -e \"s|conftestf\.${ac_objext}||g\"`"
cobjtype="`${FILE} conftestc.${ac_objext} | sed -e \"s|conftestc\.${ac_objext}||g\"`"
if test "$fobjtype" != "$cobjtype" ; then
AC_MSG_ERROR([**** Incompatible Fortran and C Object File Types! ****
F77 Object File Type produced by \"${F77} ${FFLAGS}\" is : ${fobjtype}.
C Object File Type produced by \"${CC} ${CFLAGS}\" is : ${cobjtype}.])
fi
fi
fi
fi
else
AC_MSG_RESULT([failed compilation])
fi
])
armci-mpi/m4/aclocal.m4 0000644 0001750 0001750 00000002522 12662706250 014373 0 ustar mbanck mbanck dnl This version of aclocal.m4 simply includes all of the individual
dnl components
builtin(include,aclocal_am.m4)
builtin(include,aclocal_bugfix.m4)
builtin(include,aclocal_cache.m4)
builtin(include,aclocal_cc.m4)
builtin(include,aclocal_atomic.m4)
dnl aclocal_cross.m4 uses autoconf features dated back to 2.13.
dnl too old to be useful, 07/14/2010.
dnl builtin(include,aclocal_cross.m4)
builtin(include,aclocal_cxx.m4)
builtin(include,aclocal_f77.m4)
builtin(include,aclocal_f77new.m4)
builtin(include,aclocal_util.m4)
builtin(include,aclocal_subcfg.m4)
builtin(include,aclocal_make.m4)
builtin(include,aclocal_mpi.m4)
builtin(include,aclocal_shl.m4)
dnl fortran90.m4 defines [Fortran 90] as an AC_LANG
dnl which works for autoconf 2.63 and older, 07/14/2010.
dnl builtin(include,fortran90.m4)
builtin(include,aclocal_runlog.m4)
builtin(include,aclocal_fc.m4)
builtin(include,aclocal_libs.m4)
builtin(include,aclocal_attr_alias.m4)
builtin(include,ax_tls.m4)
builtin(include,aclocal_romio.m4)
dnl Add the libtool files that libtoolize wants
dnl Comment these out until libtool support is enabled.
dnl May need to change this anyway, since libtoolize
dnl does not seem to understand builtin
dnl builtin(include,libtool.m4)
dnl builtin(include,ltoptions.m4)
dnl builtin(include,ltversion.m4)
dnl builtin(include,ltsugar.m4)
dnl builtin(include,lt~obsolete.m4)
armci-mpi/m4/aclocal_shl.m4 0000644 0001750 0001750 00000035226 12662706250 015250 0 ustar mbanck mbanck dnl
dnl Definitions for creating shared libraries
dnl
dnl The purpose of these definitions is to provide common support for
dnl shared libraries, with *or without* the use of the GNU Libtool package.
dnl For many of our important platforms, the Libtool approach is overkill,
dnl and can be particularly painful for developers.
dnl
dnl To use libtool, you need macros that are defined by libtool for libtool
dnl Don't even think about the consequences of this for updating and for
dnl using user-versions of libtool :(
dnl
dnl !!!!!!!!!!!!!!!!!!!!!
dnl libtool requires ac 2.50 !!!!!!!!!!!!!!!!!
dnl
dnl builtin(include,libtool.m4)
dnl
dnl/*D
dnl PAC_ARG_SHAREDLIBS - Add --enable-sharedlibs=kind to configure.
dnl
dnl Synopsis:
dnl PAC_ARG_SHAREDLIBS
dnl
dnl Output effects:
dnl Adds '--enable-sharedlibs=kind' to the command line. If this is enabled,
dnl then based on the value of 'kind', programs are selected for the
dnl names 'CC_SHL' and 'CC_LINK_SHL' that configure will substitute for in
dnl 'Makefile.in's. These symbols are generated by 'simplemake' when
dnl shared library support is selected.
dnl The variable 'C_LINKPATH_SHL' is set to the option to specify the
dnl path to search at runtime for libraries (-rpath in gcc/GNU ld).
dnl This can be turned off with --disable-rpath , which is appropriate
dnl for libraries and for executables that may be installed in different
dnl locations.
dnl The variable 'SHLIB_EXT' is set to the extension used by shared
dnl libraries; under most forms of Unix, this is 'so'; under Mac OS/X, this
dnl is 'dylib', and under Windows (including cygwin), this is 'dll'.
dnl
dnl Supported values of 'kind' include \:
dnl+ gcc - Use gcc to create both shared objects and libraries
dnl. osx-gcc - Use gcc on Mac OS/X to create both shared objects and
dnl libraries
dnl. solaris-cc - Use native Solaris cc to create shared objects and
dnl libraries
dnl. cygwin-gcc - Use gcc on Cygwin to create shared objects and libraries
dnl- none - The same as '--disable-sharedlibs'
dnl
dnl Others will be added as experience dictates. Likely names are
dnl + libtool - For general GNU libtool
dnl - linux-pgcc - For Portland group under Linux
dnl
dnl Notes:
dnl Shared libraries are only partially implemented. Additional symbols
dnl will probably be defined, including symbols to specify how shared library
dnl search paths are specified and how shared library names are set.
dnl D*/
AC_DEFUN([PAC_ARG_SHAREDLIBS],[
AC_ARG_ENABLE(shared,
AC_HELP_STRING([--enable-shared], [Enable shared library builds]),,
enable_shared=no)
AC_ARG_ENABLE(rpath,
AC_HELP_STRING([--enable-rpath],
[Determine whether the rpath is set when programs are
compiled and linked when shared libraries are built.
The default is yes; use --disable-rpath to turn this
feature off; in that case, shared libraries will be
found according to the rules for your system (e.g., in
LD_LIBRARY_PATH)]),,enable_rpath=yes)
AC_ARG_ENABLE(sharedlibs,
[ --enable-sharedlibs=kind - Enable shared libraries. kind may be
gcc - Standard gcc and GNU ld options for creating shared libraries
osx-gcc - Special options for gcc needed only on OS/X
solaris-cc - Solaris native (SPARC) compilers for 32 bit systems
cygwin-gcc - Special options for gcc needed only for cygwin
none - same as --disable-sharedlibs
Only gcc, osx-gcc, and solaris-cc are currently supported
],,enable_sharedlibs=default)
if test "$enable_sharedlibs" = "default" ; then
if test "$enable_shared" = "yes" ; then
AS_CASE([$host],
[*-*-darwin*], [enable_sharedlibs=gcc-osx],
[*-*-cygwin*|*-*-mingw*|*-*-pw32*|*-*-cegcc*], [enable_sharedlibs=cygwin-gcc],
[*-*-sunos*], [enable_sharedlibs=solaris-gcc],
[enable_sharedlibs=gcc])
else
enable_sharedlibs=none
fi
fi
# If --enable-sharedlibs is given, but --enable-shared is not, throw
# an error
if test "$enable_sharedlibs" != "no" -a "$enable_sharedlibs" != "none" ; then
if test "$enable_shared" = "no" ; then
AC_MSG_ERROR([--enable-sharedlibs cannot be used without --enable-shared])
fi
fi
CC_SHL=true
C_LINK_SHL=true
C_LINKPATH_SHL=""
SHLIB_EXT=unknown
SHLIB_FROM_LO=no
SHLIB_INSTALL='$(INSTALL_PROGRAM)'
case "$enable_sharedlibs" in
no|none)
;;
gcc-osx|osx-gcc)
AC_MSG_RESULT([Creating shared libraries using GNU for Mac OSX])
C_LINK_SHL='${CC} -dynamiclib -undefined suppress -single_module -flat_namespace'
CC_SHL='${CC} -fPIC'
# No way in osx to specify the location of the shared libraries at link
# time (see the code in createshlib in mpich2/src/util)
# As of 10.5, -Wl,-rpath,dirname should work . The dirname
# must be a single directory, not a colon-separated list (use multiple
# -Wl,-rpath,path for each of the paths in the list). However, os x
# apparently records the library full path, so rpath isn't as useful
# as it is on other systems
C_LINKPATH_SHL=""
SHLIB_EXT="dylib"
enable_sharedlibs="osx-gcc"
;;
gcc)
AC_MSG_RESULT([Creating shared libraries using GNU])
# Not quite right yet. See mpich/util/makesharedlib
# Use syntax that works in both Make and the shell
#C_LINK_SHL='${CC} -shared -Wl,-r'
C_LINK_SHL='${CC} -shared'
# For example, include the libname as ${LIBNAME_SHL}
#C_LINK_SHL='${CC} -shared -Wl,-h,'
# May need -fPIC . Test to see which one works.
for sh_arg in "-fPIC" "-fpic" "-KPIC" ; do
PAC_C_CHECK_COMPILER_OPTION($sh_arg,works=yes,works=no)
if test "$works" = "yes" ; then
CC_SHL="${CC} ${sh_arg}"
break
fi
done
if test "$works" != "yes"; then
AC_MSG_ERROR([Cannot build shared libraries with this compiler])
fi
# This used to have -Wl,-rpath earlier, but that causes problems
# on many systems.
if test $enable_rpath = "yes" ; then
C_LINKPATH_SHL="-Wl,-rpath,"
fi
SHLIB_EXT=so
# We need to test that this isn't osx. The following is a
# simple hack
osname=`uname -s`
case $osname in
*Darwin*|*darwin*)
AC_MSG_ERROR([You must specify --enable-sharedlibs=osx-gcc for Mac OS/X])
;;
*CYGWIN*|*cygwin*)
AC_MSG_ERROR([You must specify --enable-sharedlibs=cygwin-gcc for Cygwin])
;;
*SunOS*)
AC_MSG_ERROR([You must specify --enable-sharedlibs=solaris-gcc for Solaris with gcc])
;;
esac
;;
cygwin|cygwin-gcc|gcc-cygwin)
AC_MSG_RESULT([Creating shared libraries using GNU under CYGWIN])
C_LINK_SHL='${CC} -shared'
CC_SHL='${CC}'
# DLL Libraries need to be in the user's path (!)
C_LINKPATH_SHL=""
SHLIB_EXT="dll"
enable_sharedlibs="cygwin-gcc"
;;
libtool)
# set TRY_LIBTOOL to yes to experiment with libtool. You are on your
# own - only send fixes, not bug reports.
if test "$TRY_LIBTOOL" != yes ; then
AC_MSG_ERROR([Creating shared libraries using libtool not yet supported])
else
# Using libtool requires a heavy-weight process to test for
# various stuff that libtool needs. Without this, you'll get a
# bizarre error message about libtool being unable to find
# configure.in or configure.ac (!)
# Libtool expects to see at least enable-shared.
if test "X$enable_shared" = "X" ; then enable_shared=yes ; fi
# Initialize libtool
# This works, but libtool version 2 places the object files
# in a different place, making it harder to integrate with
# our base approach. Disabling for now
dnl LT_PREREQ([2.2.6])
dnl LT_INIT([disable-shared])
AC_MSG_ERROR([To use this test verison, edit aclocal_shl.m4])
# Likely to be
# either CC or CC_SHL is libtool $cc
CC_SHL='${LIBTOOL} --mode=compile ${CC}'
# CC_LINK_SHL includes the final installation path
# For many systems, the link may need to include *all* libraries
# (since many systems don't allow any unsatisfied dependencies)
# We need to give libtool the .lo file, not the .o files
SHLIB_FROM_LO=yes
# We also need to add -no-undefined when the compiler is gcc and
# we are building under cygwin
sysname=`uname -s | tr abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ`
isCygwin=no
case "$sysname" in
*CYGWIN*) isCygwin=yes ;;
esac
if test "$isCygwin" = yes ; then
C_LINK_SHL='${LIBTOOL} --mode=link ${CC} -no-undefined -rpath ${libdir}'
else
C_LINK_SHL='${LIBTOOL} --mode=link ${CC} -rpath ${libdir}'
fi
if test $enable_rpath = "yes" ; then
C_LINKPATH_SHL="-rpath "
fi
# We also need a special install process with libtool. Note that this
# will also install the static libraries
SHLIB_INSTALL='$(LIBTOOL) --mode=install $(INSTALL_PROGRAM)'
# Note we may still need to add
#'$(LIBTOOL) --mode=finish $(libdir)'
fi
;;
dnl
dnl Other, such as solaris-cc
solaris|solaris-cc)
AC_MSG_RESULT([Creating shared libraries using Solaris])
# pic32 is appropriate for both 32 and 64 bit Solaris
C_LINK_SHL='${CC} -G -xcode=pic32'
CC_SHL='${CC} -xcode=pic32'
if test $enable_rpath = "yes" ; then
C_LINKPATH_SHL="-R"
fi
SHLIB_EXT=so
enable_sharedlibs="solaris-cc"
;;
solaris-gcc)
# This is the same as gcc, except for the C_LINKPATH_SHL
AC_MSG_RESULT([Creating shared libraries using Solaris with gcc])
C_LINK_SHL='${CC} -shared'
CC_SHL='${CC} -fPIC'
if test $enable_rpath = "yes" ; then
C_LINKPATH_SHL="-R"
fi
SHLIB_EXT=so
enable_sharedlibs="solaris-gcc"
;;
linuxppc-xlc)
# This is only the beginning of xlc support, thanks to andy@vpac.org
CC_SHL='${CC} -qmkshrobj'
# More recent versions allow multiple args, separated by commas
if test $enable_rpath = "yes" ; then
C_LINKPATH_SHL="-Wl,-rpath,"
fi
#C_LINKPATH_SHL="-Wl,-rpath -Wl,"
C_LINK_SHL='${CC} -shared -qmkshrobj'
SHLIB_EXT=so
# Note that the full line should be more like
# $CLINKER -shared -qmkshrobj -Wl,-h,$libbase.$slsuffix -o ../shared/$libbase.$slsuffix *.o $OtherLibs
# for the appropriate values of $libbase and $slsuffix
# The -h name sets the name of the object; this is necessary to
# ensure that the dynamic linker can find the proper shared library.
;;
*)
AC_MSG_ERROR([Unknown value $enable_sharedlibs for enable-sharedlibs. Values should be gcc or osx-gcc])
enable_sharedlibs=no
;;
esac
# Check for the shared-library extension
PAC_CC_SHLIB_EXT
dnl
AC_SUBST(CC_SHL)
AC_SUBST(C_LINK_SHL)
AC_SUBST(C_LINKPATH_SHL)
AC_SUBST(SHLIB_EXT)
AC_SUBST(SHLIB_FROM_LO)
AC_SUBST(SHLIB_INSTALL)
])
dnl /*D
dnl PAC_xx_SHAREDLIBS - Get compiler and linker for shared libraries
dnl These routines may be used to determine the compiler and the
dnl linker to be used in creating shared libraries
dnl Rather than set predefined variable names, they set an argument
dnl (if provided)
dnl
dnl Synopsis
dnl PAC_CC_SHAREDLIBS(type,CCvar,CLINKvar)
dnl D*/
AC_DEFUN([PAC_CC_SHAREDLIBS],
[
pac_kinds=$1
ifelse($1,,[
pac_prog=""
AC_CHECK_PROG(pac_prog,gcc,yes,no)
# If we are gcc but OS X, set the special type
# We need a similar setting for cygwin
if test "$pac_prog" = yes ; then
osname=`uname -s`
case $osname in
*Darwin*|*darwin*) pac_kinds=gcc-osx
;;
*) pac_kinds=gcc
;;
esac
fi
pac_prog=""
AC_CHECK_PROG(pac_prog,libtool,yes,no)
if test "$pac_prog" = yes ; then pac_kinds="$pac_kinds libtool" ; fi
])
for pac_arg in $pac_kinds ; do
case $pac_arg in
gcc)
# For example, include the libname as ${LIBNAME_SHL}
#C_LINK_SHL='${CC} -shared -Wl,-h,'
pac_cc_sharedlibs='gcc -shared'
# Make sure we select the correct fpic option
PAC_C_CHECK_COMPILER_OPTION(-fPIC,fPIC_OK=yes,fPIC_OK=no)
if test "$fPIC_OK" != yes ; then
PAC_C_CHECK_COMPILER_OPTION(-fpic,fpic_ok=yes,fpic_ok=no)
if test "$fpic_ok" != yes ; then
AC_MSG_ERROR([Neither -fpic nor -fPIC accepted by $CC])
else
pac_cc_sharedlibs="$pac_cc_sharedlibs -fpic"
fi
else
pac_cc_sharedlibs="$pac_cc_sharedlibs -fPIC"
fi
pac_clink_sharedlibs='gcc -shared'
pac_type_sharedlibs=gcc
;;
gcc-osx|osx-gcc)
pac_clink_sharedlibs='${CC} -dynamiclib -undefined suppress -single_module -flat_namespace'
pac_cc_sharedlibs='${CC} -fPIC'
pac_type_sharedlibs=gcc-osx
;;
libtool)
AC_CHECK_PROGS(LIBTOOL,libtool,false)
if test "$LIBTOOL" = "false" ; then
AC_MSG_WARN([Could not find libtool])
else
# Likely to be
# either CC or CC_SHL is libtool $cc
pac_cc_sharedlibs'${LIBTOOL} -mode=compile ${CC}'
pac_clink_sharedlibs='${LIBTOOL} -mode=link ${CC} -rpath ${libdir}'
pac_type_sharedlibs=libtool
fi
;;
*)
;;
esac
if test -n "$pac_cc_sharedlibs" ; then break ; fi
done
if test -z "$pac_cc_sharedlibs" ; then pac_cc_sharedlibs=true ; fi
if test -z "$pac_clink_sharedlibs" ; then pac_clink_sharedlibs=true ; fi
ifelse($2,,CC_SHL=$pac_cc_sharedlibs,$2=$pac_cc_sharedlibs)
ifelse($3,,C_LINK_SHL=$pac_clink_sharedlibs,$3=$pac_clink_sharedlibs)
ifelse($4,,SHAREDLIB_TYPE=$pac_type_sharedlibs,$4=$pac_type_sharedlibs)
])
dnl This macro ensures that all of the necessary substitutions are
dnl made by any subdirectory configure (which may simply SUBST the
dnl necessary values rather than trying to determine them from scratch)
dnl This is a more robust (and, in the case of libtool, only
dnl managable) method.
AC_DEFUN([PAC_CC_SUBDIR_SHLIBS],[
AC_SUBST(CC_SHL)
AC_SUBST(C_LINK_SHL)
AC_SUBST(LIBTOOL)
AC_SUBST(ENABLE_SHLIB)
AC_SUBST(SHLIB_EXT)
if test "$ENABLE_SHLIB" = "libtool" ; then
if test -z "$LIBTOOL" ; then
AC_MSG_WARN([libtool selected for shared library support but LIBTOOL is not defined])
fi
# Libtool needs master_top_builddir
if test "X$master_top_builddir" = "X" ; then
AC_MSG_ERROR([Libtool requires master_top_builddir - check configure.in sources])
fi
AC_SUBST(master_top_builddir)
fi
])
dnl PAC_CC_SHLIB_EXT - get the extension for shared libraries
dnl Set the variable SHLIB_EXT if it is other than unknown.
AC_DEFUN([PAC_CC_SHLIB_EXT],[
# Not all systems use .so as the extension for shared libraries (cygwin
# and OSX are two important examples). If we did not set the SHLIB_EXT,
# then try and determine it. We need this to properly implement
# clean steps that look for libfoo.$SHLIB_EXT .
if test "$SHLIB_EXT" = "unknown" ; then
osname=`uname -s`
case $osname in
*Darwin*|*darwin*) SHLIB_EXT=dylib
;;
*CYGWIN*|*cygwin*) SHLIB_EXT=dll
;;
*Linux*|*LINUX*|*SunOS*) SHLIB_EXT=so
;;
esac
fi
])
armci-mpi/m4/aclocal_bugfix.m4 0000644 0001750 0001750 00000005153 12662706250 015742 0 ustar mbanck mbanck dnl This internal macro fails to work properly with OTHER internal macros.
dnl Basically, if the prologue is [], then no message should be generated.
dnl This macro is in autoconf 2.52
m4_define([AC_LANG_PROGRAM(Fortran 77)],
[m4_if([$1],[[[]]],,[m4_ifval([$1],
[m4_warn([syntax], [$0: ignoring PROLOGUE: $1])])])dnl
program main
$2
end])
dnl/*D
dnl PAC_PROG_CHECK_INSTALL_WORKS - Check whether the install program in INSTALL
dnl works.
dnl
dnl Synopsis:
dnl PAC_PROG_CHECK_INSTALL_WORKS
dnl
dnl Output Effect:
dnl Sets the variable 'INSTALL' to the value of 'ac_sh_install' if
dnl a file cannot be installed into a local directory with the 'INSTALL'
dnl program
dnl
dnl Notes:
dnl The 'AC_PROG_INSTALL' scripts tries to avoid broken versions of
dnl install by avoiding directories such as '/usr/sbin' where some
dnl systems are known to have bad versions of 'install'. Unfortunately,
dnl this is exactly the sort of test-on-name instead of test-on-capability
dnl that 'autoconf' is meant to eliminate. The test in this script
dnl is very simple but has been adequate for working around problems
dnl on Solaris, where the '/usr/sbin/install' program (known by
dnl autoconf to be bad because it is in /usr/sbin) is also reached by a
dnl soft link through /bin, which autoconf believes is good.
dnl
dnl No variables are cached to ensure that we do not make a mistake in
dnl our choice of install program.
dnl
dnl The Solaris configure requires the directory name to immediately
dnl follow the '-c' argument, rather than the more common
dnl.vb
dnl args sourcefiles destination-dir
dnl.ve
dnl D*/
AC_DEFUN([PAC_PROG_CHECK_INSTALL_WORKS],[
if test -z "$INSTALL" ; then
AC_MSG_RESULT([No install program available])
else
# first make any "confdb/install-sh -c" into an absolute path
# this is a hack, but it's still much cleaner than anything else I could
# come up with (see tt#1007) [goodell@]
AS_CASE(["$INSTALL"],
[/*],[:],
[*install-sh*],[INSTALL="$master_top_srcdir/$INSTALL"])
# Check that this install really works
rm -f conftest
echo "Test file" > conftest
if test ! -d .conftest ; then mkdir .conftest ; fi
AC_MSG_CHECKING([whether install works])
if $INSTALL conftest .conftest >/dev/null 2>&1 ; then
installOk=yes
else
installOk=no
fi
rm -rf .conftest conftest
AC_MSG_RESULT($installOk)
if test "$installOk" = no ; then
if test -n "$ac_install_sh" ; then
INSTALL=$ac_install_sh
else
AC_MSG_ERROR([Unable to find working install])
fi
fi
fi
])
armci-mpi/m4/ax_pthread.m4 0000644 0001750 0001750 00000032676 12663426407 015135 0 ustar mbanck mbanck # ===========================================================================
# http://www.gnu.org/software/autoconf-archive/ax_pthread.html
# ===========================================================================
#
# SYNOPSIS
#
# AX_PTHREAD([ACTION-IF-FOUND[, ACTION-IF-NOT-FOUND]])
#
# DESCRIPTION
#
# This macro figures out how to build C programs using POSIX threads. It
# sets the PTHREAD_LIBS output variable to the threads library and linker
# flags, and the PTHREAD_CFLAGS output variable to any special C compiler
# flags that are needed. (The user can also force certain compiler
# flags/libs to be tested by setting these environment variables.)
#
# Also sets PTHREAD_CC to any special C compiler that is needed for
# multi-threaded programs (defaults to the value of CC otherwise). (This
# is necessary on AIX to use the special cc_r compiler alias.)
#
# NOTE: You are assumed to not only compile your program with these flags,
# but also link it with them as well. e.g. you should link with
# $PTHREAD_CC $CFLAGS $PTHREAD_CFLAGS $LDFLAGS ... $PTHREAD_LIBS $LIBS
#
# If you are only building threads programs, you may wish to use these
# variables in your default LIBS, CFLAGS, and CC:
#
# LIBS="$PTHREAD_LIBS $LIBS"
# CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
# CC="$PTHREAD_CC"
#
# In addition, if the PTHREAD_CREATE_JOINABLE thread-attribute constant
# has a nonstandard name, defines PTHREAD_CREATE_JOINABLE to that name
# (e.g. PTHREAD_CREATE_UNDETACHED on AIX).
#
# Also HAVE_PTHREAD_PRIO_INHERIT is defined if pthread is found and the
# PTHREAD_PRIO_INHERIT symbol is defined when compiling with
# PTHREAD_CFLAGS.
#
# ACTION-IF-FOUND is a list of shell commands to run if a threads library
# is found, and ACTION-IF-NOT-FOUND is a list of commands to run it if it
# is not found. If ACTION-IF-FOUND is not specified, the default action
# will define HAVE_PTHREAD.
#
# Please let the authors know if this macro fails on any platform, or if
# you have any other suggestions or comments. This macro was based on work
# by SGJ on autoconf scripts for FFTW (http://www.fftw.org/) (with help
# from M. Frigo), as well as ac_pthread and hb_pthread macros posted by
# Alejandro Forero Cuervo to the autoconf macro repository. We are also
# grateful for the helpful feedback of numerous users.
#
# Updated for Autoconf 2.68 by Daniel Richard G.
#
# LICENSE
#
# Copyright (c) 2008 Steven G. Johnson
# Copyright (c) 2011 Daniel Richard G.
#
# This program is free software: you can redistribute it and/or modify it
# under the terms of the GNU General Public License as published by the
# Free Software Foundation, either version 3 of the License, or (at your
# option) any later version.
#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
# Public License for more details.
#
# You should have received a copy of the GNU General Public License along
# with this program. If not, see .
#
# As a special exception, the respective Autoconf Macro's copyright owner
# gives unlimited permission to copy, distribute and modify the configure
# scripts that are the output of Autoconf when processing the Macro. You
# need not follow the terms of the GNU General Public License when using
# or distributing such scripts, even though portions of the text of the
# Macro appear in them. The GNU General Public License (GPL) does govern
# all other use of the material that constitutes the Autoconf Macro.
#
# This special exception to the GPL applies to versions of the Autoconf
# Macro released by the Autoconf Archive. When you make and distribute a
# modified version of the Autoconf Macro, you may extend this special
# exception to the GPL to apply to your modified version as well.
#serial 21
AU_ALIAS([ACX_PTHREAD], [AX_PTHREAD])
AC_DEFUN([AX_PTHREAD], [
AC_REQUIRE([AC_CANONICAL_HOST])
AC_LANG_PUSH([C])
ax_pthread_ok=no
# We used to check for pthread.h first, but this fails if pthread.h
# requires special compiler flags (e.g. on True64 or Sequent).
# It gets checked for in the link test anyway.
# First of all, check if the user has set any of the PTHREAD_LIBS,
# etcetera environment variables, and if threads linking works using
# them:
if test x"$PTHREAD_LIBS$PTHREAD_CFLAGS" != x; then
save_CFLAGS="$CFLAGS"
CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
save_LIBS="$LIBS"
LIBS="$PTHREAD_LIBS $LIBS"
AC_MSG_CHECKING([for pthread_join in LIBS=$PTHREAD_LIBS with CFLAGS=$PTHREAD_CFLAGS])
AC_TRY_LINK_FUNC([pthread_join], [ax_pthread_ok=yes])
AC_MSG_RESULT([$ax_pthread_ok])
if test x"$ax_pthread_ok" = xno; then
PTHREAD_LIBS=""
PTHREAD_CFLAGS=""
fi
LIBS="$save_LIBS"
CFLAGS="$save_CFLAGS"
fi
# We must check for the threads library under a number of different
# names; the ordering is very important because some systems
# (e.g. DEC) have both -lpthread and -lpthreads, where one of the
# libraries is broken (non-POSIX).
# Create a list of thread flags to try. Items starting with a "-" are
# C compiler flags, and other items are library names, except for "none"
# which indicates that we try without any flags at all, and "pthread-config"
# which is a program returning the flags for the Pth emulation library.
ax_pthread_flags="pthreads none -Kthread -kthread lthread -pthread -pthreads -mthreads pthread --thread-safe -mt pthread-config"
# The ordering *is* (sometimes) important. Some notes on the
# individual items follow:
# pthreads: AIX (must check this before -lpthread)
# none: in case threads are in libc; should be tried before -Kthread and
# other compiler flags to prevent continual compiler warnings
# -Kthread: Sequent (threads in libc, but -Kthread needed for pthread.h)
# -kthread: FreeBSD kernel threads (preferred to -pthread since SMP-able)
# lthread: LinuxThreads port on FreeBSD (also preferred to -pthread)
# -pthread: Linux/gcc (kernel threads), BSD/gcc (userland threads)
# -pthreads: Solaris/gcc
# -mthreads: Mingw32/gcc, Lynx/gcc
# -mt: Sun Workshop C (may only link SunOS threads [-lthread], but it
# doesn't hurt to check since this sometimes defines pthreads too;
# also defines -D_REENTRANT)
# ... -mt is also the pthreads flag for HP/aCC
# pthread: Linux, etcetera
# --thread-safe: KAI C++
# pthread-config: use pthread-config program (for GNU Pth library)
case ${host_os} in
solaris*)
# On Solaris (at least, for some versions), libc contains stubbed
# (non-functional) versions of the pthreads routines, so link-based
# tests will erroneously succeed. (We need to link with -pthreads/-mt/
# -lpthread.) (The stubs are missing pthread_cleanup_push, or rather
# a function called by this macro, so we could check for that, but
# who knows whether they'll stub that too in a future libc.) So,
# we'll just look for -pthreads and -lpthread first:
ax_pthread_flags="-pthreads pthread -mt -pthread $ax_pthread_flags"
;;
darwin*)
ax_pthread_flags="-pthread $ax_pthread_flags"
;;
esac
# Clang doesn't consider unrecognized options an error unless we specify
# -Werror. We throw in some extra Clang-specific options to ensure that
# this doesn't happen for GCC, which also accepts -Werror.
AC_MSG_CHECKING([if compiler needs -Werror to reject unknown flags])
save_CFLAGS="$CFLAGS"
ax_pthread_extra_flags="-Werror"
CFLAGS="$CFLAGS $ax_pthread_extra_flags -Wunknown-warning-option -Wsizeof-array-argument"
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([int foo(void);],[foo()])],
[AC_MSG_RESULT([yes])],
[ax_pthread_extra_flags=
AC_MSG_RESULT([no])])
CFLAGS="$save_CFLAGS"
if test x"$ax_pthread_ok" = xno; then
for flag in $ax_pthread_flags; do
case $flag in
none)
AC_MSG_CHECKING([whether pthreads work without any flags])
;;
-*)
AC_MSG_CHECKING([whether pthreads work with $flag])
PTHREAD_CFLAGS="$flag"
;;
pthread-config)
AC_CHECK_PROG([ax_pthread_config], [pthread-config], [yes], [no])
if test x"$ax_pthread_config" = xno; then continue; fi
PTHREAD_CFLAGS="`pthread-config --cflags`"
PTHREAD_LIBS="`pthread-config --ldflags` `pthread-config --libs`"
;;
*)
AC_MSG_CHECKING([for the pthreads library -l$flag])
PTHREAD_LIBS="-l$flag"
;;
esac
save_LIBS="$LIBS"
save_CFLAGS="$CFLAGS"
LIBS="$PTHREAD_LIBS $LIBS"
CFLAGS="$CFLAGS $PTHREAD_CFLAGS $ax_pthread_extra_flags"
# Check for various functions. We must include pthread.h,
# since some functions may be macros. (On the Sequent, we
# need a special flag -Kthread to make this header compile.)
# We check for pthread_join because it is in -lpthread on IRIX
# while pthread_create is in libc. We check for pthread_attr_init
# due to DEC craziness with -lpthreads. We check for
# pthread_cleanup_push because it is one of the few pthread
# functions on Solaris that doesn't have a non-functional libc stub.
# We try pthread_create on general principles.
AC_LINK_IFELSE([AC_LANG_PROGRAM([#include
static void routine(void *a) { a = 0; }
static void *start_routine(void *a) { return a; }],
[pthread_t th; pthread_attr_t attr;
pthread_create(&th, 0, start_routine, 0);
pthread_join(th, 0);
pthread_attr_init(&attr);
pthread_cleanup_push(routine, 0);
pthread_cleanup_pop(0) /* ; */])],
[ax_pthread_ok=yes],
[])
LIBS="$save_LIBS"
CFLAGS="$save_CFLAGS"
AC_MSG_RESULT([$ax_pthread_ok])
if test "x$ax_pthread_ok" = xyes; then
break;
fi
PTHREAD_LIBS=""
PTHREAD_CFLAGS=""
done
fi
# Various other checks:
if test "x$ax_pthread_ok" = xyes; then
save_LIBS="$LIBS"
LIBS="$PTHREAD_LIBS $LIBS"
save_CFLAGS="$CFLAGS"
CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
# Detect AIX lossage: JOINABLE attribute is called UNDETACHED.
AC_MSG_CHECKING([for joinable pthread attribute])
attr_name=unknown
for attr in PTHREAD_CREATE_JOINABLE PTHREAD_CREATE_UNDETACHED; do
AC_LINK_IFELSE([AC_LANG_PROGRAM([#include ],
[int attr = $attr; return attr /* ; */])],
[attr_name=$attr; break],
[])
done
AC_MSG_RESULT([$attr_name])
if test "$attr_name" != PTHREAD_CREATE_JOINABLE; then
AC_DEFINE_UNQUOTED([PTHREAD_CREATE_JOINABLE], [$attr_name],
[Define to necessary symbol if this constant
uses a non-standard name on your system.])
fi
AC_MSG_CHECKING([if more special flags are required for pthreads])
flag=no
case ${host_os} in
aix* | freebsd* | darwin*) flag="-D_THREAD_SAFE";;
osf* | hpux*) flag="-D_REENTRANT";;
solaris*)
if test "$GCC" = "yes"; then
flag="-D_REENTRANT"
else
# TODO: What about Clang on Solaris?
flag="-mt -D_REENTRANT"
fi
;;
esac
AC_MSG_RESULT([$flag])
if test "x$flag" != xno; then
PTHREAD_CFLAGS="$flag $PTHREAD_CFLAGS"
fi
AC_CACHE_CHECK([for PTHREAD_PRIO_INHERIT],
[ax_cv_PTHREAD_PRIO_INHERIT], [
AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include ]],
[[int i = PTHREAD_PRIO_INHERIT;]])],
[ax_cv_PTHREAD_PRIO_INHERIT=yes],
[ax_cv_PTHREAD_PRIO_INHERIT=no])
])
AS_IF([test "x$ax_cv_PTHREAD_PRIO_INHERIT" = "xyes"],
[AC_DEFINE([HAVE_PTHREAD_PRIO_INHERIT], [1], [Have PTHREAD_PRIO_INHERIT.])])
LIBS="$save_LIBS"
CFLAGS="$save_CFLAGS"
# More AIX lossage: compile with *_r variant
if test "x$GCC" != xyes; then
case $host_os in
aix*)
AS_CASE(["x/$CC"],
[x*/c89|x*/c89_128|x*/c99|x*/c99_128|x*/cc|x*/cc128|x*/xlc|x*/xlc_v6|x*/xlc128|x*/xlc128_v6],
[#handle absolute path differently from PATH based program lookup
AS_CASE(["x$CC"],
[x/*],
[AS_IF([AS_EXECUTABLE_P([${CC}_r])],[PTHREAD_CC="${CC}_r"])],
[AC_CHECK_PROGS([PTHREAD_CC],[${CC}_r],[$CC])])])
;;
esac
fi
fi
test -n "$PTHREAD_CC" || PTHREAD_CC="$CC"
AC_SUBST([PTHREAD_LIBS])
AC_SUBST([PTHREAD_CFLAGS])
AC_SUBST([PTHREAD_CC])
# Finally, execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND:
if test x"$ax_pthread_ok" = xyes; then
ifelse([$1],,[AC_DEFINE([HAVE_PTHREAD],[1],[Define if you have POSIX threads libraries and header files.])],[$1])
:
else
ax_pthread_ok=no
$2
fi
AC_LANG_POP
])dnl AX_PTHREAD
armci-mpi/m4/aclocal_make.m4 0000644 0001750 0001750 00000017456 12662706250 015404 0 ustar mbanck mbanck dnl
dnl We need routines to check that make works. Possible problems with
dnl make include
dnl
dnl It is really gnumake, and contrary to the documentation on gnumake,
dnl it insists on screaming everytime a directory is changed. The fix
dnl is to add the argument --no-print-directory to the make
dnl
dnl It is really BSD 4.4 make, and can't handle 'include'. For some
dnl systems, this can be fatal; there is no fix (other than removing this
dnl alleged make).
dnl
dnl It is the OSF V3 make, and can't handle a comment in a block of target
dnl code. There is no acceptable fix.
dnl
dnl
dnl
dnl
dnl Find a make program if none is defined.
AC_DEFUN([PAC_PROG_MAKE_PROGRAM],[true
if test "X$MAKE" = "X" ; then
AC_CHECK_PROGS(MAKE,make gnumake nmake pmake smake)
fi
])dnl
dnl/*D
dnl PAC_PROG_MAKE_INCLUDE - Check whether make supports include
dnl
dnl Synopsis:
dnl PAC_PROG_MAKE_INCLUDE([action if true],[action if false])
dnl
dnl Output Effect:
dnl None
dnl
dnl Notes:
dnl This checks for makes that do not support 'include filename'. Some
dnl versions of BSD 4.4 make required '#include' instead; some versions of
dnl 'pmake' have the same syntax.
dnl
dnl See Also:
dnl PAC_PROG_MAKE
dnl
dnl D*/
AC_DEFUN([PAC_PROG_MAKE_INCLUDE],[
AC_CACHE_CHECK([whether make supports include],pac_cv_prog_make_include,[
AC_REQUIRE([PAC_PROG_MAKE_PROGRAM])
# This is needed for Mac OSX 10.5
rm -rf conftest.dSYM
rm -f conftest
cat > conftest <<.
ALL:
@echo "success"
.
cat > conftest1 <<.
include conftest
.
pac_str=`$MAKE -f conftest1 2>&1`
# This is needed for Mac OSX 10.5
rm -rf conftest.dSYM
rm -f conftest conftest1
if test "$pac_str" != "success" ; then
pac_cv_prog_make_include="no"
else
pac_cv_prog_make_include="yes"
fi
])
if test "$pac_cv_prog_make_include" = "no" ; then
ifelse([$2],,:,[$2])
else
ifelse([$1],,:,[$1])
fi
])dnl
dnl/*D
dnl PAC_PROG_MAKE_ALLOWS_COMMENTS - Check whether comments are allowed in
dnl shell commands in a makefile
dnl
dnl Synopsis:
dnl PAC_PROG_MAKE_ALLOWS_COMMENTS([false text])
dnl
dnl Output Effect:
dnl Issues a warning message if comments are not allowed in a makefile.
dnl Executes the argument if one is given.
dnl
dnl Notes:
dnl Some versions of OSF V3 make do not all comments in action commands.
dnl
dnl See Also:
dnl PAC_PROG_MAKE
dnl D*/
dnl
AC_DEFUN([PAC_PROG_MAKE_ALLOWS_COMMENTS],[
AC_CACHE_CHECK([whether make allows comments in actions],
pac_cv_prog_make_allows_comments,[
AC_REQUIRE([PAC_PROG_MAKE_PROGRAM])
# This is needed for Mac OSX 10.5
rm -rf conftest.dSYM
rm -f conftest
cat > conftest <<.
SHELL=/bin/sh
ALL:
@# This is a valid comment!
@echo "success"
.
pac_str=`$MAKE -f conftest 2>&1`
# This is needed for Mac OSX 10.5
rm -rf conftest.dSYM
rm -f conftest
if test "$pac_str" != "success" ; then
pac_cv_prog_make_allows_comments="no"
else
pac_cv_prog_make_allows_comments="yes"
fi
])
if test "$pac_cv_prog_make_allows_comments" = "no" ; then
AC_MSG_WARN([Your make does not allow comments in target code.
Using this make may cause problems when building programs.
You should consider using gnumake instead.])
ifelse([$1],,[$1])
fi
])dnl
dnl/*D
dnl PAC_PROG_MAKE_VPATH - Check whether make supports source-code paths.
dnl
dnl Synopsis:
dnl PAC_PROG_MAKE_VPATH
dnl
dnl Output Effect:
dnl Sets the variable 'VPATH' to either
dnl.vb
dnl VPATH = .:${srcdir}
dnl.ve
dnl or
dnl.vb
dnl .PATH: . ${srcdir}
dnl.ve
dnl
dnl Notes:
dnl The test checks that the path works with implicit targets (some makes
dnl support only explicit targets with 'VPATH' or 'PATH').
dnl
dnl NEED TO DO: Check that $< works on explicit targets.
dnl
dnl See Also:
dnl PAC_PROG_MAKE
dnl
dnl D*/
AC_DEFUN([PAC_PROG_MAKE_VPATH],[
AC_SUBST(VPATH)
dnl AM_IGNORE(VPATH)
AC_CACHE_CHECK([for virtual path format],
pac_cv_prog_make_vpath,[
AC_REQUIRE([PAC_PROG_MAKE_PROGRAM])
# This is needed for Mac OSX 10.5
rm -rf conftest.dSYM
rm -rf conftest*
mkdir conftestdir
cat >conftestdir/a.c < conftest <&1 | grep 'conftestdir/a.c'`
if test -n "$ac_out" ; then
pac_cv_prog_make_vpath="VPATH"
else
rm -f conftest
cat > conftest <&1 | grep 'conftestdir/a.c'`
if test -n "$ac_out" ; then
pac_cv_prog_make_vpath=".PATH"
else
pac_cv_prog_make_vpath="neither VPATH nor .PATH works"
fi
fi
# This is needed for Mac OSX 10.5
rm -rf conftest.dSYM
rm -rf conftest*
])
if test "$pac_cv_prog_make_vpath" = "VPATH" ; then
VPATH='VPATH=.:${srcdir}'
elif test "$pac_cv_prog_make_vpath" = ".PATH" ; then
VPATH='.PATH: . ${srcdir}'
fi
])dnl
dnl/*D
dnl PAC_PROG_MAKE_SET_CFLAGS - Check whether make sets CFLAGS
dnl
dnl Synopsis:
dnl PAC_PROG_MAKE_SET_CFLAGS([action if true],[action if false])
dnl
dnl Output Effects:
dnl Executes the first argument if 'CFLAGS' is set by 'make'; executes
dnl the second argument if 'CFLAGS' is not set by 'make'.
dnl
dnl Notes:
dnl If 'CFLAGS' is set by make, you may wish to override that choice in your
dnl makefile.
dnl
dnl See Also:
dnl PAC_PROG_MAKE
dnl D*/
AC_DEFUN([PAC_PROG_MAKE_SET_CFLAGS],[
AC_CACHE_CHECK([whether make sets CFLAGS],
pac_cv_prog_make_set_cflags,[
AC_REQUIRE([PAC_PROG_MAKE_PROGRAM])
# This is needed for Mac OSX 10.5
rm -rf conftest.dSYM
rm -f conftest
cat > conftest <&1`
# This is needed for Mac OSX 10.5
rm -rf conftest.dSYM
rm -f conftest
if test "$pac_str" = "XX" ; then
pac_cv_prog_make_set_cflags="no"
else
pac_cv_prog_make_set_cflags="yes"
fi
])
if test "$pac_cv_prog_make_set_cflags" = "no" ; then
ifelse([$2],,:,[$2])
else
ifelse([$1],,:,[$1])
fi
])dnl
dnl/*D
dnl PAC_PROG_MAKE_CLOCK_SKEW - Check whether there is a problem with
dnl clock skew in suing make.
dnl
dnl Effect:
dnl Sets the cache variable 'pac_cv_prog_make_found_clock_skew' to yes or no
dnl D*/
AC_DEFUN([PAC_PROG_MAKE_CLOCK_SKEW],[
AC_CACHE_CHECK([whether clock skew breaks make],
pac_cv_prog_make_found_clock_skew,[
AC_REQUIRE([PAC_PROG_MAKE_PROGRAM])
# This is needed for Mac OSX 10.5
rm -rf conftest.dSYM
rm -f conftest*
cat > conftest < conftest.out 2>&1
if grep -i skew conftest >/dev/null 2>&1 ; then
pac_cv_prog_make_found_clock_skew=yes
else
pac_cv_prog_make_found_clock_skew=no
fi
# This is needed for Mac OSX 10.5
rm -rf conftest.dSYM
rm -f conftest*
])
dnl We should really do something if we detect clock skew. The question is,
dnl what?
if test "$pac_cv_prog_make_found_clock_skew" = "yes" ; then
AC_MSG_WARN([Clock skew found by make. The configure and build may fail.
Consider building in a local instead of NFS filesystem.])
fi
])
dnl/*D
dnl PAC_PROG_MAKE - Checks for the varieties of MAKE, including support for
dnl VPATH
dnl
dnl Synopsis:
dnl PAC_PROG_MAKE
dnl
dnl Output Effect:
dnl Sets 'MAKE' to the make program to use if 'MAKE' is not already set.
dnl Sets the variable 'SET_CFLAGS' to 'CFLAGS =' if make sets 'CFLAGS'.
dnl
dnl Notes:
dnl This macro uses 'PAC_PROG_MAKE_INCLUDE',
dnl 'PAC_PROG_MAKE_ALLOWS_COMMENTS', 'PAC_PROG_MAKE_VPATH', and
dnl 'PAC_PROG_MAKE_SET_CFLAGS'. See those commands for details about their
dnl actions.
dnl
dnl It may call 'AC_PROG_MAKE_SET', which sets 'SET_MAKE' to 'MAKE = @MAKE@'
dnl if the make program does not set the value of make, otherwise 'SET_MAKE'
dnl is set to empty; if the make program echos the directory name, then
dnl 'SET_MAKE' is set to 'MAKE = $MAKE'.
dnl D*/
AC_DEFUN([PAC_PROG_MAKE],[
PAC_PROG_MAKE_PROGRAM
PAC_PROG_MAKE_CLOCK_SKEW
PAC_PROG_MAKE_INCLUDE
PAC_PROG_MAKE_ALLOWS_COMMENTS
PAC_PROG_MAKE_VPATH
AC_SUBST(SET_CFLAGS)
dnl AM_IGNORE(SET_CFLAGS)
PAC_PROG_MAKE_SET_CFLAGS([SET_CFLAGS='CFLAGS='])
if test "$pac_cv_prog_make_echos_dir" = "no" ; then
AC_PROG_MAKE_SET
else
SET_MAKE="MAKE=${MAKE-make}"
fi
])
armci-mpi/m4/aclocal_cache.m4 0000644 0001750 0001750 00000031347 12662706250 015525 0 ustar mbanck mbanck dnl
dnl/*D
dnl AC_CACHE_LOAD - Replacement for autoconf cache load
dnl
dnl Notes:
dnl Caching in autoconf is broken (at least through version 2.13).
dnl The problem is that the cache is read
dnl without any check for whether it makes any sense to read it.
dnl A common problem is a build on a shared file system; connecting to
dnl a different computer and then building within the same directory will
dnl lead to at best error messages from configure and at worse a build that
dnl is wrong but fails only at run time (e.g., wrong datatype sizes used).
dnl Later versions of autoconf do include some checks for changes in the
dnl environment that impact the choices, but still misses problems with
dnl multiple different systems.
dnl
dnl This fixes that by requiring the user to explicitly enable caching
dnl before the cache file will be loaded.
dnl
dnl To use this version of 'AC_CACHE_LOAD', you need to include
dnl 'aclocal_cache.m4' in your 'aclocal.m4' file. The sowing 'aclocal.m4'
dnl file includes this file.
dnl
dnl If no --enable-cache or --disable-cache option is selected, the
dnl command causes configure to keep track of the system being configured
dnl in a config.system file; if the current system matches the value stored
dnl in that file (or there is neither a config.cache nor config.system file),
dnl configure will enable caching. In order to ensure that the configure
dnl tests make sense, the values of CC, F77, F90, and CXX are also included
dnl in the config.system file. In addition, the value of PATH is included
dnl to ensure that changes in the PATH that might select a different version
dnl of a program with the same name (such as a native make versus gnumake)
dnl are detected.
dnl
dnl Bugs:
dnl This does not work with the Cygnus configure because the enable arguments
dnl are processed *after* AC_CACHE_LOAD (!). To address this, we avoid
dnl changing the value of enable_cache, and use real_enable_cache, duplicating
dnl the "notgiven" value.
dnl
dnl The environment variable CONFIGURE_DEBUG_CACHE, if set to yes,
dnl will cause additional data to be written out during the configure process.
dnl This can be helpful in debugging the cache file process.
dnl
dnl See Also:
dnl PAC_ARG_CACHING
dnl D*/
define([AC_CACHE_LOAD],
[if test "$CONFIGURE_DEBUG_CACHE" = yes ; then
oldopts="$-"
clearMinusX=no
set -x
if test "$oldopts" != "$-" ; then
clearMinusX=yes
fi
fi
if test "X$cache_system" = "X" ; then
# A default file name, just in case
cache_system="config.system"
if test "$cache_file" != "/dev/null" ; then
# Get the directory for the cache file, if any
changequote(,)
dnl Be careful to ensure that there is no doubled slash
cache_system=`echo $cache_file | sed -e 's%^\(.*/\)[^/]*%\1config.system%'`
changequote([,])
test "x$cache_system" = "x$cache_file" && cache_system="config.system"
# else
# We must *not* set enable_cache to no because we need to know if
# enable_cache was not set.
# enable_cache=no
fi
fi
dnl
dnl The "action-if-not-given" part of AC_ARG_ENABLE is not executed until
dnl after the AC_CACHE_LOAD is executed (!). Thus, the value of
dnl enable_cache if neither --enable-cache or --disable-cache is selected
dnl is null. Just in case autoconf ever fixes this, we test both cases.
dnl
dnl Include PATH in the cache.system file since changing the path can
dnl change which versions of programs are found (such as vendor make
dnl or GNU make).
dnl
#
# Get a test value and flag whether we should remove/replace the
# cache_system file (do so unless cache_system_ok is yes)
# FC and F77 should be synonyms. Save both in case
# We include the xxxFLAGS in case the user is using the flags to change
# the language (either input or output) of the compiler. E.g.,
# using -xarch=v9 on Solaris to select 64 bit output or using -D_BSD_SOURCE
# with gcc to get different header files on input.
cleanargs=`echo "$CC $F77 $FC $CXX $F90 $CFLAGS $FFLAGS $CXXFLAGS $F90FLAGS $PATH" | tr '"' ' '`
if uname -srm >/dev/null 2>&1 ; then
cache_system_text="`uname -srm` $cleanargs"
else
cache_system_text="-no-uname- $cleanargs"
fi
cache_system_ok=no
#
if test -z "$real_enable_cache" ; then
real_enable_cache=$enable_cache
if test -z "$real_enable_cache" ; then real_enable_cache="notgiven" ; fi
fi
if test "X$real_enable_cache" = "Xnotgiven" ; then
# check for valid cache file
if test -z "$cache_system" ; then cache_system="config.system" ; fi
if uname -srm >/dev/null 2>&1 ; then
if test -f "$cache_system" -a -n "$cache_system_text" ; then
if test "$cache_system_text" = "`cat $cache_system`" ; then
real_enable_cache="yes"
cache_system_ok=yes
fi
elif test ! -f "$cache_system" -a -n "$cache_system_text" ; then
# remove the cache file because it may not correspond to our
# system
if test "$cache_file" != "/dev/null" ; then
rm -f $cache_file
fi
real_enable_cache="yes"
fi
fi
fi
if test "X$real_enable_cache" = "Xyes" -a "$cache_file" = "/dev/null" ; then
real_enable_cache=no
fi
if test "X$real_enable_cache" = "Xyes" ; then
if test -r "$cache_file" ; then
echo "loading cache $cache_file"
if test -w "$cache_file" ; then
# Clean the cache file (ergh)
PAC_CACHE_CLEAN
fi
. $cache_file
else
echo "Configure in `pwd` creating cache $cache_file"
> $cache_file
rm -f $cache_system
fi
else
cache_file="/dev/null"
fi
# Remember our location and the name of the cachefile
pac_cv_my_conf_dir=`pwd`
dnl do not include the cachefile name, since this may contain the process
dnl number and cause comparisons looking for changes to the cache file
dnl to detect a change that isn't real.
dnl pac_cv_my_cachefile=$cachefile
#
# Update the cache_system file if necessary
if test "$cache_system_ok" != yes ; then
if test -n "$cache_system" ; then
rm -f $cache_system
echo $cache_system_text > $cache_system
fi
fi
if test "$clearMinusX" = yes ; then
set +x
fi
])
dnl
dnl/*D
dnl PAC_ARG_CACHING - Enable caching of results from a configure execution
dnl
dnl Synopsis:
dnl PAC_ARG_CACHING
dnl
dnl Output Effects:
dnl Adds '--enable-cache' and '--disable-cache' to the command line arguments
dnl accepted by 'configure'.
dnl
dnl See Also:
dnl AC_CACHE_LOAD
dnl D*/
dnl Add this call to the other ARG_ENABLE calls. Note that the values
dnl set here are redundant; the LOAD_CACHE call relies on the way autoconf
dnl initially processes ARG_ENABLE commands.
AC_DEFUN([PAC_ARG_CACHING],[
AC_ARG_ENABLE(cache,
AC_HELP_STRING([--enable-cache], [Turn on configure caching]),,
[enable_cache="notgiven"])
])
dnl Clean the cache of extraneous quotes that AC_CACHE_SAVE may add
dnl
AC_DEFUN([PAC_CACHE_CLEAN],[
rm -f confcache
sed -e "s/'\\\\''//g" -e "s/'\\\\/'/" -e "s/\\\\'/'/" \
-e "s/'\\\\''//g" $cache_file > confcache
if cmp -s $cache_file confcache ; then
:
else
if test -w $cache_file ; then
echo "updating cache $cache_file"
cat confcache > $cache_file
else
echo "not updating unwritable cache $cache_file"
fi
fi
rm -f confcache
if test "$DEBUG_AUTOCONF_CACHE" = "yes" ; then
echo "Results of cleaned cache file:"
echo "--------------------------------------------------------"
cat $cache_file
echo "--------------------------------------------------------"
fi
])
dnl/*D
dnl PAC_SUBDIR_CACHE - Create a cache file before ac_output for subdirectory
dnl configures.
dnl
dnl Synopsis:
dnl PAC_SUBDIR_CACHE(when)
dnl
dnl Input Parameter:
dnl . when - Indicates when the cache should be created (optional)
dnl If 'always', create a new cache file. This option
dnl should be used if any of the cache parameters (such as
dnl CFLAGS or LDFLAGS) may have changed.
dnl
dnl Output Effects:
dnl
dnl Create a cache file before ac_output so that subdir configures don't
dnl make mistakes.
dnl We can't use OUTPUT_COMMANDS to remove the cache file, because those
dnl commands are executed *before* the subdir configures.
dnl
dnl D*/
AC_DEFUN([PAC_SUBDIR_CACHE],[])
AC_DEFUN([PAC_SUBDIR_CACHE_OLD],[
if test "x$1" = "xalways" -o \( "$cache_file" = "/dev/null" -a "X$real_enable_cache" = "Xnotgiven" \) ; then
# Use an absolute directory to help keep the subdir configures from getting
# lost
cache_file=`pwd`/$$conf.cache
touch $cache_file
dnl
dnl For Autoconf 2.52+, we should ensure that the environment is set
dnl for the cache. Make sure that we get the values and set the
dnl xxx_set variables properly
ac_cv_env_CC_set=set
ac_cv_env_CC_value=$CC
ac_cv_env_CFLAGS_set=${CFLAGS+set}
ac_cv_env_CFLAGS_value=$CFLAGS
ac_cv_env_CPP_set=set
ac_cv_env_CPP_value=$CPP
ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
ac_cv_env_CPPFLAGS_value=$CPPFLAGS
ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
ac_cv_env_LDFLAGS_value=$LDFLAGS
ac_cv_env_LIBS_set=${LIBS+set}
ac_cv_env_LIBS_value=$LIBS
ac_cv_env_FC_set=${FC+set}
ac_cv_env_FC_value=$FC
ac_cv_env_F77_set=${F77+set}
ac_cv_env_F77_value=$F77
ac_cv_env_F90_set=${F90+set}
ac_cv_env_F90_value=$F90
ac_cv_env_FFLAGS_set=${FFLAGS+set}
ac_cv_env_FFLAGS_value=$FFLAGS
ac_cv_env_CXX_set=${CXX+set}
ac_cv_env_CXX_value=$CXX
ac_env_CC_set=set
ac_env_CC_value=$CC
ac_env_CFLAGS_set=${CFLAGS+set}
ac_env_CFLAGS_value=$CFLAGS
ac_env_CPP_set=set
ac_env_CPP_value=$CPP
ac_env_CPPFLAGS_set=${CPPFLAGS+set}
ac_env_CPPFLAGS_value=$CPPFLAGS
ac_env_LDFLAGS_set=${LDFLAGS+set}
ac_env_LDFLAGS_value=$LDFLAGS
ac_env_LIBS_set=${LIBS+set}
ac_env_LIBS_value=$LIBS
ac_env_FC_set=${FC+set}
ac_env_FC_value=$FC
ac_env_F77_set=${F77+set}
ac_env_F77_value=$F77
ac_env_F90_set=${F90+set}
ac_env_F90_value=$F90
ac_env_FFLAGS_set=${FFLAGS+set}
ac_env_FFLAGS_value=$FFLAGS
ac_env_CXX_set=${CXX+set}
ac_env_CXX_value=$CXX
dnl other parameters are
dnl build_alias, host_alias, target_alias
# It turns out that A C CACHE_SAVE can't be invoked more than once
# with data that contains blanks. What happens is that the quotes
# that it adds get quoted and then added again. To avoid this,
# we strip off the outer quotes for all cached variables
dnl We add pac_cv_my_conf_dir to give the source of this cachefile,
dnl and pac_cv_my_cachefile to indicate how it chose the cachefile.
pac_cv_my_conf_dir=`pwd`
pac_cv_my_cachefile=$cachefile
AC_CACHE_SAVE
PAC_CACHE_CLEAN
ac_configure_args="$ac_configure_args -enable-cache"
fi
dnl Unconditionally export these values. Subdir configures break otherwise
export CC
export CFLAGS
export LDFLAGS
export LIBS
export CPPFLAGS
export CPP
export FC
export F77
export F90
export CXX
export FFLAGS
export CCFLAGS
])
AC_DEFUN([PAC_SUBDIR_CACHE_CLEANUP],[])
AC_DEFUN([PAC_SUBDIR_CACHE_CLEANUP_OLD],[
if test "$cache_file" != "/dev/null" -a "X$real_enable_cache" = "Xnotgiven" ; then
rm -f $cache_file
cache_file=/dev/null
fi
])
dnl
dnl The following three macros support the sharing of configure results
dnl by configure scripts, including ones that are not run with
dnl AC_CONFIG_SUBDIRS (the cachefiles managed by --enable-cache can
dnl only be used with AC_CONFIG_SUBDIRS; creating a autoconf-style
dnl cachefile before the the end of the autoconf process will often
dnl cause problems.
dnl
AC_DEFUN([PAC_CREATE_BASE_CACHE],[
AC_ARG_ENABLE(base-cache,
AC_HELP_STRING([--enable-base-cache],
[Enable the use of a simple cache for the subsidiary
configure scripts]),,enable_base_cache=default)
# The default case is controlled by the environment variable CONF_USE_CACHEFILE
if test "$enable_base_cache" = "default" ; then
if test "$CONF_USE_CACHEFILE" = yes ; then
enable_base_cache=yes
else
enable_base_cache=no
fi
fi
if test "$enable_base_cache" != no ; then
if test "$enable_base_cache" = yes ; then
basecachefile=`pwd`/cache.base
else
basecachefile=`pwd`/$enable_base_cache
fi
set | grep ac_cv > $basecachefile
# Tell other configures to load this file
echo "Creating and exporting the base cache file $basecachefile"
CONF_BASE_CACHEFILE=$basecachefile
export CONF_BASE_CACHEFILE
fi
])
AC_DEFUN([PAC_LOAD_BASE_CACHE],[
if test -n "$CONF_BASE_CACHEFILE" -a -s "$CONF_BASE_CACHEFILE" ; then
echo "Loading base cachefile $CONF_BASE_CACHEFILE"
. $CONF_BASE_CACHEFILE
export CONF_BASE_CACHEFILE
fi
])
AC_DEFUN([PAC_UPDATE_BASE_CACHE],[
if test -n "$CONF_BASE_CACHEFILE" -a -s "$CONF_BASE_CACHEFILE" ; then
set | grep ac_cv > $CONF_BASE_CACHEFILE.new
if cmp -s $CONF_BASE_CACHEFILE.new $CONF_BASE_CACHEFILE ; then
:
else
echo "Replacing $CONF_BASE_CACHEFILE"
mv $CONF_BASE_CACHEFILE.new $CONF_BASE_CACHEFILE
fi
fi
])
armci-mpi/m4/aclocal_romio.m4 0000644 0001750 0001750 00000060011 12662706250 015575 0 ustar mbanck mbanck dnl
dnl This files contains additional macros for using autoconf to
dnl build configure scripts.
dnl
dnl Almost all of this file is taken from the aclocal.m4 of MPICH
dnl
dnl Get the format of Fortran names. Uses F77, FFLAGS, and sets WDEF.
dnl If the test fails, sets NOF77 to 1, HAVE_FORTRAN to 0.
dnl
dnl
AC_DEFUN([PAC_GET_FORTNAMES],[
rm -f confftest.f confftest.o
cat > confftest.f < /dev/null 2>&1
if test ! -s confftest.o ; then
AC_MSG_WARN([Unable to test Fortran compiler. Compiling a test
program failed to produce an object file])
NOF77=1
elif test -z "$FORTRANNAMES" ; then
# MAC OS X (and probably FreeBSD need strings - (not strings -a)
# Cray doesn't accept -a ...
allstrings="-a"
if test $arch_CRAY ; then
allstrings=""
elif strings - confftest.o < /dev/null >/dev/null 2>&1 ; then
allstrings="-"
elif strings -a confftest.o < /dev/null >/dev/null 2>&1 ; then
allstrings="-a"
fi
nameform1=`strings $allstrings confftest.o | grep mpir_init_fop_ | head -1`
nameform2=`strings $allstrings confftest.o | grep MPIR_INIT_FOP | head -1`
nameform3=`strings $allstrings confftest.o | grep mpir_init_fop | head -1`
nameform4=`strings $allstrings confftest.o | grep mpir_init_fop__ | head -1`
rm -f confftest.f confftest.o
if test -n "$nameform4" ; then
echo "Fortran externals are lower case and have two trailing underscores"
FORTRANNAMES="FORTRANDOUBLEUNDERSCORE"
elif test -n "$nameform1" ; then
# We don't set this in CFLAGS; it is a default case
echo "Fortran externals have a trailing underscore and are lowercase"
FORTRANNAMES="FORTRANUNDERSCORE"
elif test -n "$nameform2" ; then
echo "Fortran externals are uppercase"
FORTRANNAMES="FORTRANCAPS"
elif test -n "$nameform3" ; then
echo "Fortran externals are lower case"
FORTRANNAMES="FORTRANNOUNDERSCORE"
else
AC_MSG_WARN([Unable to determine the form of Fortran external names.
Make sure that the compiler $F77 can be run on this system.
Turning off Fortran (-nof77 being assumed)])
NOF77=1
fi
fi
if test -n "$FORTRANNAMES" ; then
WDEF="-D$FORTRANNAMES"
fi
# Delete confftest files with any extension. This catches the case
# where auxillary files, such as coverage files, are removed.
rm -f confftest.*
])dnl
dnl
define(PAC_GET_SPECIAL_SYSTEM_INFO,[
#
if test -n "$arch_IRIX"; then
AC_MSG_CHECKING(for IRIX OS version)
dnl This block of code replaces a generic "IRIX" arch value with
dnl IRIX__
dnl For example
dnl IRIX_5_4400 (IRIX 5.x, using MIPS 4400)
osversion=`uname -r | sed 's/\..*//'`
dnl Note that we need to allow brackets here, so we briefly turn off
dnl the macro quotes
changequote(,)dnl
dnl Get the second field (looking for 6.1)
osvminor=`uname -r | sed 's/[0-9]\.\([0-9]*\)\..*/\1/'`
changequote([,])dnl
AC_MSG_RESULT($osversion)
dnl Get SGI processor count by quick hack
AC_MSG_CHECKING(for IRIX cpucount)
changequote(,)dnl
cpucount=`hinv | grep '[0-9]* [0-9]* MHZ IP[0-9]* Proc' | cut -f 1 -d' '`
if test "$cpucount" = "" ; then
cpucount=`hinv | grep 'Processor [0-9]*:' | wc -l | sed -e 's/ //g'`
fi
changequote([,])dnl
if test "$cpucount" = "" ; then
AC_MSG_RESULT([Could not determine cpucount. Please send])
hinv
AC_MSG_ERROR([to romio-maint@mcs.anl.gov])
fi
AC_MSG_RESULT($cpucount)
dnl
AC_MSG_CHECKING(for IRIX cpumodel)
dnl The tail -1 is necessary for multiple processor SGI boxes
dnl We might use this to detect SGI multiprocessors and recommend
dnl -comm=shared
cputype=`hinv -t cpu | tail -1 | cut -f 3 -d' '`
if test -z "$cputype" ; then
AC_MSG_RESULT([Could not get cputype from hinv -t cpu command. Please send])
hinv -t cpu 2>&1
hinv -t cpu | cut -f 3 -d' ' 2>&1
AC_MSG_ERROR([to romio-maint@mcs.anl.gov])
fi
AC_MSG_RESULT($cputype)
dnl echo "checking for osversion and cputype"
dnl cputype may contain R4400, R2000A/R3000, or something else.
dnl We may eventually need to look at it.
if test -z "$osversion" ; then
AC_MSG_RESULT([Could not determine OS version. Please send])
uname -a
AC_MSG_ERROR([to romio-maint@mcs.anl.gov])
elif test $osversion = 4 ; then
true
elif test $osversion = 5 ; then
true
elif test $osversion = 6 ; then
true
else
AC_MSG_RESULT([Could not recognize the version of IRIX (got $osversion).
ROMIO knows about versions 4, 5 and 6; the version being returned from
uname -r is $osversion. Please send])
uname -a 2>&1
hinv 2>&1
AC_MSG_ERROR([to romio-maint@mcs.anl.gov])
fi
AC_MSG_CHECKING(for cputype)
OLD_ARCH=IRIX
IRIXARCH="$ARCH_$osversion"
dnl Now, handle the chip set
changequote(,)dnl
cputype=`echo $cputype | sed -e 's%.*/%%' -e 's/R//' | tr -d "[A-Z]"`
changequote([,])dnl
case $cputype in
3000) ;;
4000) ;;
4400) ;;
4600) ;;
5000) ;;
8000) ;;
10000);;
12000);;
*)
AC_MSG_WARN([Unexpected IRIX/MIPS chipset $cputype. Please send the output])
uname -a 2>&1
hinv 2>&1
AC_MSG_WARN([to romio-maint@mcs.anl.gov
ROMIO will continue and assume that the cputype is
compatible with a MIPS 4400 processor.])
cputype=4400
;;
esac
AC_MSG_RESULT($cputype)
IRIXARCH="$IRIXARCH_$cputype"
echo "IRIX-specific architecture is $IRIXARCH"
fi
])dnl
dnl
dnl
define(PAC_TEST_MPI,[
AC_MSG_CHECKING(if a simple MPI program compiles and links)
rm -f mpitest.c
cat > mpitest.c <&5
$cmd >&5 2>&5
if test ! -x conftest ; then
echo "$as_me:$LINENO: failed program was:" >&5
sed 's/^/| /' mpitest.c >&5
rm -f conftest mpitest.c
AC_MSG_ERROR([Unable to compile a simple MPI program.
Use environment variables to provide the location of MPI libraries and
include directories])
else
rm -f conftest mpitest.c
fi
AC_MSG_RESULT(yes)
])dnl
dnl
dnl
dnl
define(PAC_NEEDS_FINT,[
AC_MSG_CHECKING(if MPI_Fint is defined in the MPI implementation)
cat > mpitest1.c < /dev/null 2>&1
if test ! -s mpitest1.o ; then
NEEDS_MPI_FINT="#define NEEDS_MPI_FINT"
CFLAGS="$CFLAGS -DNEEDS_MPI_FINT"
AC_MSG_RESULT(no)
rm -f mpitest1.o mpitest1.c
else
NEEDS_MPI_FINT=""
AC_MSG_RESULT(yes)
rm -f mpitest1.o mpitest1.c
fi
])dnl
dnl
define(PAC_MPI_LONG_LONG_INT,[
AC_MSG_CHECKING(if MPI_LONG_LONG_INT is defined in mpi.h)
rm -f mpitest.c
cat > mpitest.c < /dev/null 2>&1
if test -x conftest ; then
AC_MSG_RESULT(yes)
AC_DEFINE(HAVE_MPI_LONG_LONG_INT,,[Define if mpi has long long it])
else
AC_MSG_RESULT(no)
fi
rm -f conftest mpitest.c
])dnl
dnl
dnl PAC_LONG_LONG_64: check if there is a 64-bit long long
dnl
define(PAC_LONG_LONG_64,[
if test -n "$longlongsize" ; then
if test "$longlongsize" = 8 ; then
echo "defining MPI_Offset as long long in C and integer*8 in Fortran"
AC_DEFINE(HAVE_LONG_LONG_64,,[Define if long long is 64 bits])
DEFINE_MPI_OFFSET="typedef long long MPI_Offset;"
FORTRAN_MPI_OFFSET="integer*8"
LL="\%lld"
elif test "$longlongsize" = "int" ; then # a hack to set MPI_Offset as int
echo "defining MPI_Offset as int in C and integer in Fortran"
DEFINE_MPI_OFFSET="typedef int MPI_Offset;"
FORTRAN_MPI_OFFSET="integer"
AC_DEFINE(MPI_OFFSET_IS_INT,,[Define if MPI_Offset is int])
LL="\%d"
MPI_OFFSET_KIND1="!"
MPI_OFFSET_KIND2="!"
else
echo "defining MPI_Offset as long in C and integer in Fortran"
DEFINE_MPI_OFFSET="typedef long MPI_Offset;"
FORTRAN_MPI_OFFSET="integer"
LL="\%ld"
MPI_OFFSET_KIND1="!"
MPI_OFFSET_KIND2="!"
fi
else
PAC_GET_TYPE_SIZE(long long, longlongsize)
if test -n "$longlongsize" ; then
if test "$longlongsize" = 8 ; then
PAC_TEST_LONG_LONG()
else
echo "defining MPI_Offset as long in C and integer in Fortran"
DEFINE_MPI_OFFSET="typedef long MPI_Offset;"
FORTRAN_MPI_OFFSET="integer"
LL="\%ld"
MPI_OFFSET_KIND1="!"
MPI_OFFSET_KIND2="!"
fi
else
dnl check if longlong is not supported or only its size cannot be determined
dnl because the program cannot be run.
rm -f ltest.c
cat > ltest.c < /dev/null 2>&1
if test -x conftest ; then
echo "assuming size of long long is 8bytes; use '-longlongsize' to indicate otherwise"
rm -f conftest ltest.c
echo "defining MPI_Offset as long long in C and integer*8 in Fortran"
AC_DEFINE(HAVE_LONG_LONG_64,,[Define if long long is 64 bits])
DEFINE_MPI_OFFSET="typedef long long MPI_Offset;"
FORTRAN_MPI_OFFSET="integer*8"
LL="\%lld"
else
echo "assuming long long is not available; use '-longlongsize' to indicate otherwise"
echo "defining MPI_Offset as long in C and integer in Fortran"
DEFINE_MPI_OFFSET="typedef long MPI_Offset;"
FORTRAN_MPI_OFFSET="integer"
LL="\%ld"
MPI_OFFSET_KIND1="!"
MPI_OFFSET_KIND2="!"
fi
fi
fi
])dnl
dnl
dnl
define(PAC_MPI_INFO,[
AC_MSG_CHECKING(if MPI_Info functions are defined in the MPI implementation)
rm -f mpitest.c
cat > mpitest.c < /dev/null 2>&1
if test -x conftest ; then
AC_MSG_RESULT(yes)
AC_DEFINE(HAVE_MPI_INFO,1,[Define if MPI_Info available])
HAVE_MPI_INFO="#define HAVE_MPI_INFO"
MPI_FINFO1="!"
MPI_FINFO2="!"
MPI_FINFO3="!"
MPI_FINFO4="!"
else
AC_MSG_RESULT(no)
BUILD_MPI_INFO=1
MPI_FINFO1=" INTEGER MPI_MAX_INFO_KEY, MPI_MAX_INFO_VAL"
MPI_FINFO2=" PARAMETER (MPI_MAX_INFO_KEY=255, MPI_MAX_INFO_VAL=1024)"
MPI_FINFO3=" INTEGER MPI_INFO_NULL"
MPI_FINFO4=" PARAMETER (MPI_INFO_NULL=0)"
fi
rm -f conftest mpitest.c
])dnl
dnl
dnl
define(PAC_MPI_DARRAY_SUBARRAY,[
AC_MSG_CHECKING(if darray and subarray constructors are defined in the MPI implementation)
rm -f mpitest.c
cat > mpitest.c < /dev/null 2>&1
if test -x conftest ; then
AC_MSG_RESULT(yes)
AC_DEFINE(HAVE_MPI_DARRAY_SUBARRAY,,[Define if MPI Darray available])
HAVE_MPI_DARRAY_SUBARRAY="#define HAVE_MPI_DARRAY_SUBARRAY"
MPI_FARRAY1="!"
MPI_FARRAY2="!"
MPI_FARRAY3="!"
MPI_FARRAY4="!"
MPI_FARRAY5="!"
MPI_FARRAY6="!"
MPI_FARRAY7="!"
else
AC_MSG_RESULT(no)
BUILD_MPI_ARRAY=1
MPI_FARRAY1=" INTEGER MPI_ORDER_C, MPI_ORDER_FORTRAN"
MPI_FARRAY2=" PARAMETER (MPI_ORDER_C=56, MPI_ORDER_FORTRAN=57)"
MPI_FARRAY3=" INTEGER MPI_DISTRIBUTE_BLOCK, MPI_DISTRIBUTE_CYCLIC"
MPI_FARRAY4=" INTEGER MPI_DISTRIBUTE_NONE, MPI_DISTRIBUTE_DFLT_DARG"
MPI_FARRAY5=" PARAMETER (MPI_DISTRIBUTE_BLOCK=121, MPI_DISTRIBUTE_CYCLIC=122)"
MPI_FARRAY6=" PARAMETER (MPI_DISTRIBUTE_NONE=123)"
MPI_FARRAY7=" PARAMETER (MPI_DISTRIBUTE_DFLT_DARG=-49767)"
fi
rm -f conftest mpitest.c
])dnl
dnl
dnl
define(PAC_CHECK_MPI_SGI_INFO_NULL,[
AC_MSG_CHECKING([if MPI_INFO_NULL is defined in mpi.h])
rm -f mpitest.c
cat > mpitest.c < /dev/null 2>&1
if test -x conftest ; then
AC_MSG_RESULT(yes)
cp adio/sgi/mpi3.1/*.h include
else
AC_MSG_RESULT(no)
fi
rm -f conftest mpitest.c
])dnl
dnl
dnl
dnl
define(PAC_CHECK_MPIOF_H,[
AC_MSG_CHECKING(if mpiof.h is included in mpif.h)
rm -f mpitest.f
cat > mpitest.f < /dev/null 2>&1
if test -x conftest ; then
AC_MSG_RESULT(yes)
MPIOF_H_INCLUDED=1
else
AC_MSG_RESULT(no)
fi
rm -f conftest mpitest.f
])dnl
dnl
dnl
dnl check if pread64 is defined in IRIX. needed on IRIX 6.5
dnl
define(PAC_HAVE_PREAD64,[
AC_MSG_CHECKING(if pread64 is defined)
rm -f conftest.c
cat > conftest.c <
main()
{
int fd=0, buf=0, i=0;
off64_t off=0;
pread64(fd, &buf, i, off);
}
EOF
rm -f conftest
$CC $USER_CFLAGS -o conftest conftest.c > /dev/null 2>&1
if test -x conftest ; then
AC_MSG_RESULT(yes)
AC_DEFINE(HAVE_PREAD64,,[Define if pread64 available])
else
AC_MSG_RESULT(no)
fi
rm -f conftest conftest.c
])dnl
dnl
dnl
define(PAC_TEST_MPI_SGI_type_is_contig,[
AC_MSG_CHECKING(if MPI_SGI_type_is_contig is defined)
rm -f mpitest.c
cat > mpitest.c < /dev/null 2>&1
if test -x conftest ; then
AC_MSG_RESULT(yes)
else
AC_MSG_RESULT(no)
AC_DEFINE(NO_MPI_SGI_type_is_contig,,[Define if no MPI type is contig])
fi
rm -f conftest mpitest.c
])dnl
dnl
dnl
dnl
define(PAC_TEST_MPI_COMBINERS,[
AC_MSG_CHECKING(if MPI-2 combiners are defined in mpi.h)
rm -f mpitest.c
cat > mpitest.c < /dev/null 2>&1
if test -x conftest ; then
AC_MSG_RESULT(yes)
AC_DEFINE(HAVE_MPI_COMBINERS,,[Define if MPI combiners available])
else
AC_MSG_RESULT(no)
fi
rm -f conftest mpitest.c
])dnl
dnl
dnl
dnl PAC_MPI_OFFSET_KIND()
dnl
dnl tries to determine the Fortran 90 kind parameter for 8-byte integers
dnl
define(PAC_MPI_OFFSET_KIND,
[
# This is needed for Mac OSX 10.5
rm -rf conftest.dSYM
rm -f conftest*
# Determine the extension for Fortran 90 files (not all compilers accept
# .f and not all accept .f90)
if test -z "$ac_f90ext" ; then
if test -z "$F90" ; then
AC_CHECK_PROGS(F90,f90 xlf90 pgf90 ifort epcf90 f95 fort xlf95 lf95 pathf90 g95 fc ifc efc)
fi
AC_MSG_CHECKING([for extension for Fortran 90 programs])
ac_f90ext="f90"
ac_f90compile='${F90-f90} -c $F90FLAGS conftest.$ac_f90ext 1>&AC_FD_CC'
cat > conftest.$ac_f90ext < conftest.$ac_f90ext < conftest.$ac_f90ext
program main
integer i
i = selected_int_kind(16)
open(8, file="conftest.out", form="formatted")
write (8,*) i
close(8)
stop
end
EOF
if test -z "$F90" ; then
F90=f90
fi
KINDVAL=""
if $F90 -o conftest conftest.$ac_f90ext >/dev/null 2>&1 ; then
./conftest >/dev/null 2>&1
if test -s conftest.out ; then
KINDVAL=`cat conftest.out`
fi
fi
# This is needed for Mac OSX 10.5
rm -rf conftest.dSYM
rm -f conftest*
if test -n "$KINDVAL" -a "$KINDVAL" != "-1" ; then
AC_MSG_RESULT($KINDVAL)
MPI_OFFSET_KIND1=" INTEGER MPI_OFFSET_KIND"
MPI_OFFSET_KIND2=" PARAMETER (MPI_OFFSET_KIND=$KINDVAL)"
else
AC_MSG_RESULT(unavailable)
fi
])dnl
dnl
dnl
define(PAC_TEST_MPI_HAVE_OFFSET_KIND,[
AC_MSG_CHECKING(if MPI_OFFSET_KIND is defined in mpif.h)
rm -f mpitest.f
cat > mpitest.f < /dev/null 2>&1
if test -x conftest ; then
AC_MSG_RESULT(yes)
MPI_OFFSET_KIND1="!"
MPI_OFFSET_KIND2="!"
else
AC_MSG_RESULT(no)
fi
rm -f conftest mpitest.f
])dnl
dnl
dnl
dnl PAC_GET_XFS_MEMALIGN
dnl
dnl
define(PAC_GET_XFS_MEMALIGN,
[AC_MSG_CHECKING([for memory alignment needed for direct I/O])
rm -f memalignval
rm -f /tmp/romio_tmp.bin
AC_TEST_PROGRAM([#include
#include
#include
#include
main() {
struct dioattr st;
int fd = open("/tmp/romio_tmp.bin", O_RDWR | O_CREAT, 0644);
FILE *f=fopen("memalignval","w");
if (fd == -1) exit(1);
if (!f) exit(1);
fcntl(fd, F_DIOINFO, &st);
fprintf( f, "%u\n", st.d_mem);
exit(0);
}],Pac_CV_NAME=`cat memalignval`,Pac_CV_NAME="")
rm -f memalignval
rm -f /tmp/romio_tmp.bin
if test -n "$Pac_CV_NAME" -a "$Pac_CV_NAME" != 0 ; then
AC_MSG_RESULT($Pac_CV_NAME)
CFLAGS="$CFLAGS -DXFS_MEMALIGN=$Pac_CV_NAME"
else
AC_MSG_RESULT(unavailable, assuming 128)
CFLAGS="$CFLAGS -DXFS_MEMALIGN=128"
fi
])dnl
dnl
dnl
dnl Look for a style of VPATH. Known forms are
dnl VPATH = .:dir
dnl .PATH: . dir
dnl
dnl Defines VPATH or .PATH with . $(srcdir)
dnl Requires that vpath work with implicit targets
dnl NEED TO DO: Check that $< works on explicit targets.
dnl
define(PAC_MAKE_VPATH,[
AC_SUBST(VPATH)
AC_MSG_CHECKING(for virtual path format)
# This is needed for Mac OSX 10.5
rm -rf conftest.dSYM
rm -rf conftest*
mkdir conftestdir
cat >conftestdir/a.c < conftest <&1 | grep 'conftestdir/a.c'`
if test -n "$ac_out" ; then
AC_MSG_RESULT(VPATH)
VPATH='VPATH=.:$(srcdir)'
else
rm -f conftest
cat > conftest <&1 | grep 'conftestdir/a.c'`
if test -n "$ac_out" ; then
AC_MSG_RESULT(.PATH)
VPATH='.PATH: . $(srcdir)'
else
AC_MSG_RESULT(neither VPATH nor .PATH works)
fi
fi
# This is needed for Mac OSX 10.5
rm -rf conftest.dSYM
rm -rf conftest*
])dnl
dnl
define(PAC_HAVE_MOUNT_NFS,[
AC_MSG_CHECKING([if MOUNT_NFS is defined in the include files])
rm -f conftest.c
cat > conftest.c <
#include
main()
{
int i=MOUNT_NFS;
}
EOF
rm -f conftest
$CC $USER_CFLAGS -o conftest conftest.c > /dev/null 2>&1
if test -x conftest ; then
AC_MSG_RESULT(yes)
ROMIO_HAVE_MOUNT_NFS=1
AC_DEFINE(HAVE_MOUNT_NFS,,[Define if MOUNT_NFS defined])
else
ROMIO_HAVE_MOUNT_NFS=0
AC_MSG_RESULT(no)
fi
rm -f conftest conftest.c
])dnl
dnl
dnl
dnl PAC_MPI_OFFSET_KIND_4BYTE()
dnl
dnl tries to determine the Fortran 90 kind parameter for 4-byte integers
dnl
define(PAC_MPI_OFFSET_KIND_4BYTE,
[AC_MSG_CHECKING([for Fortran 90 KIND parameter for 4-byte integers])
rm -f kind.f kind.o kind
cat < kind.f
program main
integer i
i = selected_int_kind(8)
open(8, file="k.out", form="formatted")
write (8,*) i
close(8)
stop
end
EOF
if test -z "$F90" ; then
F90=f90
fi
KINDVAL=""
if $F90 -o kind kind.f >/dev/null 2>&1 ; then
./kind >/dev/null 2>&1
if test -s k.out ; then
KINDVAL=`cat k.out`
fi
fi
rm -f kind k.out kind.f kind.o
if test -n "$KINDVAL" -a "$KINDVAL" != "-1" ; then
AC_MSG_RESULT($KINDVAL)
MPI_OFFSET_KIND1=" INTEGER MPI_OFFSET_KIND"
MPI_OFFSET_KIND2=" PARAMETER (MPI_OFFSET_KIND=$KINDVAL)"
else
AC_MSG_RESULT(unavailable)
fi
])dnl
dnl
dnl
define(PAC_FUNC_STRERROR,[
AC_MSG_CHECKING([for strerror()])
rm -f conftest.c
cat > conftest.c <
main()
{
char *s = strerror(5);
}
EOF
rm -f conftest
$CC $USER_CFLAGS -o conftest conftest.c >> config.log 2>&1
if test -x conftest ; then
AC_MSG_RESULT(yes)
AC_DEFINE(HAVE_STRERROR,,[Define if strerror available])
else
AC_MSG_RESULT(no)
AC_MSG_CHECKING([for sys_errlist])
rm -f conftest.c
changequote(,)
cat > conftest.c <
main()
{
extern char *sys_errlist[];
printf("%s\n", sys_errlist[34]);
}
EOF
changequote([,])
rm -f conftest
$CC $USER_CFLAGS -o conftest conftest.c > config.log 2>&1
if test -x conftest ; then
AC_MSG_RESULT(yes)
AC_DEFINE(HAVE_SYSERRLIST,,[Define if syserrlist available])
else
AC_MSG_RESULT(no)
fi
fi
rm -f conftest conftest.c
])dnl
dnl
define(PAC_TEST_MPIR_STATUS_SET_BYTES,[
AC_MSG_CHECKING(if MPIR_Status_set_bytes is defined)
rm -f mpitest.c
cat > mpitest.c < /dev/null 2>&1
if test -x conftest ; then
AC_MSG_RESULT(yes)
AC_DEFINE(HAVE_STATUS_SET_BYTES,,[Define if status set bytes available])
else
AC_MSG_RESULT(no)
fi
rm -f conftest mpitest.c
])dnl
define(PAC_TEST_MPIU_FUNCS,[
AC_MSG_CHECKING(support for MPICH2 memory macros)
rm -f mpitest.c
cat > mpitest.c < /dev/null 2>&1
if test -x conftest ; then
AC_MSG_RESULT(yes)
AC_DEFINE(HAVE_MPIU_FUNCS,1,[Define if MPICH2 memory tracing macros defined])
else
AC_MSG_RESULT(no)
fi
rm -f conftest mpitest.c
])dnl
dnl
define(PAC_TEST_MPI_GREQUEST,[
AC_MSG_CHECKING(support for generalized requests)
rm -f mpitest.c
cat > mpitest.c < /dev/null 2>&1
if test -x conftest ; then
AC_MSG_RESULT(yes)
AC_DEFINE(HAVE_MPI_GREQUEST,1,[Define if generalized requests avaliable])
DEFINE_HAVE_MPI_GREQUEST="#define HAVE_MPI_GREQUEST 1"
else
AC_MSG_RESULT(no)
fi
rm -f conftest mpitest.c
])dnl
armci-mpi/m4/aclocal_f77new.m4 0000644 0001750 0001750 00000003071 12662706250 015570 0 ustar mbanck mbanck dnl /*D
dnl PAC_F77_WORKS_WITH_CPP
dnl
dnl Checks if Fortran 77 compiler works with C preprocessor
dnl
dnl Most systems allow the Fortran compiler to process .F and .F90 files
dnl using the C preprocessor. However, some systems either do not
dnl allow this or have serious bugs (OSF Fortran compilers have a bug
dnl that generates an error message from cpp). The following test
dnl checks to see if .F works, and if not, whether "cpp -P -C" can be used
dnl D*/
AC_DEFUN([PAC_F77_WORKS_WITH_CPP],[
AC_REQUIRE([AC_PROG_CPP])
AC_MSG_CHECKING([whether Fortran 77 compiler processes .F files with C preprocessor])
AC_LANG_PUSH([Fortran 77])
saved_f77_ext=${ac_ext}
ac_ext="F"
saved_FFLAGS="$FFLAGS"
FFLAGS="$FFLAGS $CPPFLAGS"
AC_LANG_CONFTEST([
AC_LANG_SOURCE([
program main
#define ASIZE 10
integer a(ASIZE)
end
])
])
AC_COMPILE_IFELSE([],[
pac_cv_f77_accepts_F=yes
ifelse([$1],[],[],[$1=""])
],[
pac_cv_f77_accepts_F=no
ifelse([$1],[],[:],[$1="false"])
])
# Restore Fortran 77's ac_ext but not FFLAGS
ac_ext="$saved_f77_ext"
if test "$pac_cv_f77_accepts_F" != "yes" ; then
pac_cpp_f77="$ac_cpp -C -P conftest.F > conftest.$ac_ext"
PAC_RUNLOG_IFELSE([$pac_cpp_f77],[
if test -s conftest.${ac_ext} ; then
AC_COMPILE_IFELSE([],[
pac_cv_f77_accepts_F="no, use cpp"
ifelse([$1],[],[],[$1="$CPP -C -P"])
],[])
rm -f conftest.${ac_ext}
fi
],[])
fi
FFLAGS="$saved_FFLAGS"
rm -f conftest.F
AC_LANG_POP([Fortran 77])
AC_MSG_RESULT([$pac_cv_f77_accepts_F])
])
armci-mpi/m4/aclocal_subcfg.m4 0000644 0001750 0001750 00000012757 12662706250 015737 0 ustar mbanck mbanck dnl PAC_RESET_ALL_FLAGS - Reset precious flags to those set by the user
AC_DEFUN([PAC_RESET_ALL_FLAGS],[
if test "$FROM_MPICH2" = "yes" ; then
CFLAGS="$USER_CFLAGS"
CPPFLAGS="$USER_CPPFLAGS"
CXXFLAGS="$USER_CXXFLAGS"
FFLAGS="$USER_FFLAGS"
FCFLAGS="$USER_FCFLAGS"
LDFLAGS="$USER_LDFLAGS"
LIBS="$USER_LIBS"
fi
])
dnl PAC_RESET_LINK_FLAGS - Reset precious link flags to those set by the user
AC_DEFUN([PAC_RESET_LINK_FLAGS],[
if test "$FROM_MPICH2" = "yes" ; then
LDFLAGS="$USER_LDFLAGS"
LIBS="$USER_LIBS"
fi
])
dnl Sandbox configure with additional arguments
dnl Usage: PAC_CONFIG_SUBDIR_ARGS(subdir,configure-args,action-if-success,action-if-failure)
dnl
dnl The subconfigure argument list is created based on "ac_precious_vars"
dnl instead of explicitly use of well-known Makefile variables, like
dnl CC/CFLAGS/CPPFLAGS..., this generalization is effective as long as
dnl calling configure.in declares the needed variables to be passed down
dnl to subconfigure as "precious" appropriately. The precious variable
dnl can be created in the following ways:
dnl 1) implicit declaration through use of autoconf macros, like
dnl AC_PROG_CC (declares CC/CFLAGS/CPPFLAGS/LIBS/LDFLAGS), or
dnl AC_PROG_F77 (declares F77/FFLAGS/FLIBS) ...
dnl which are in turns invoked by other subconfigure.
dnl When in doubt, check "ac_precious_var" in the calling configure.
dnl 2) explicit "precious" declaration through AC_ARG_VAR.
dnl Without correct "precious" declaration in the calling configure.in,
dnl there would be variables not being included in the subconfigure
dnl argument list.
dnl
dnl Note: I suspect this DEFUN body is underquoted in places, but it does not
dnl seem to cause problems in practice yet. [goodell@ 2010-05-18]
AC_DEFUN([PAC_CONFIG_SUBDIR_ARGS],[
AC_MSG_NOTICE([===== configuring $1 =====])
PAC_MKDIRS($1)
pac_abs_srcdir=`(cd $srcdir && pwd)`
if test -f $pac_abs_srcdir/$1/setup ; then
. $pac_abs_srcdir/$1/setup
fi
pac_subconfigure_file="$pac_abs_srcdir/$1/configure"
if test -x $pac_subconfigure_file ; then
pac_subconfig_args="$2"
# Set IFS so ac_configure_args can be tokenized
# with extra " " tokens being skipped.
saved_IFS="$IFS"
IFS="'"
for pac_arg in $ac_configure_args ; do
case "$pac_arg" in
# Ignore any null and leading blank strings.
""|" "*)
;;
*)
pac_pval=""
# Restore saved IFS so ac_precious_vars which has
# " " as separator can be correctly tokenized
IFS="$saved_IFS"
for pac_pvar in $ac_precious_vars ; do
# check if configure argument token contains the
# precious variable, i.e. "name_of_prec_var=".
pvar_in_arg=`echo $pac_arg | grep "$pac_pvar="`
if test "X$pvar_in_arg" != "X" ; then
# check if current precious variable is set in env
eval pvar_set=\${$pac_pvar+set}
if test "$pvar_set" = "set" ; then
# Append 'name_of_prec_var=value_of_prec_var'
# to the subconfigure arguments list, where
# value_of_prec_var is fetched from the env.
eval pac_pval=\${$pac_pvar}
pac_subconfig_args="$pac_subconfig_args '$pac_pvar=$pac_pval'"
break
fi
fi
done
# since the precious variable is not set in the env.,
# append the corresponding configure argument token
# to the subconfigure argument list.
if test "X$pac_pval" = "X" ; then
pac_subconfig_args="$pac_subconfig_args '$pac_arg'"
fi
# reset "'" as IFS to process ac_configure_args
saved_IFS="$IFS"
IFS="'"
;;
esac
done
# Restore IFS.
IFS="$saved_IFS"
dnl echo "pac_subconfig_args = |$pac_subconfig_args|"
dnl Add option to disable configure options checking
if test "$enable_option_checking" = no ; then
pac_subconfig_args="$pac_subconfig_args --disable-option-checking"
fi
AC_MSG_NOTICE([executing: $pac_subconfigure_file $pac_subconfig_args])
if (cd $1 && eval $pac_subconfigure_file $pac_subconfig_args) ; then
ifelse([$3],[],[:],[$3])
else
ifelse([$4],[],[:],[$4])
fi
else
if test -e $pac_subconfigure_file ; then
AC_MSG_WARN([$pac_subconfigure_file exists but is not executable])
else
AC_MSG_WARN([$pac_subconfigure_file does not exist])
fi
fi
AC_MSG_NOTICE([===== done with $1 configure =====])
# Check for any localdefs files. These may be created, so we
# look in the local directory first.
if test -f $1/localdefs ; then
. $1/localdefs
elif test -f $pac_abs_srcdir/$1/localdefs ; then
. $pac_abs_srcdir/$1/localdefs
fi
])
dnl Sandbox configure
dnl Usage: PAC_CONFIG_SUBDIR(subdir,action-if-success,action-if-failure)
AC_DEFUN([PAC_CONFIG_SUBDIR],[PAC_CONFIG_SUBDIR_ARGS([$1],[],[$2],[$3])])
armci-mpi/README.md 0000644 0001750 0001750 00000016544 12663426407 013507 0 ustar mbanck mbanck # Authors
James Dinan (MPI-2 implementation)
Jeff Hammond (MPI-3 implementation)
# Introduction
This project provides a full, high performance, portable implementation of the
ARMCI runtime system using MPI's remote memory access (RMA) functionality.
# Installing Only ARMCI-MPI
ARMCI-MPI uses autoconf and must be configured before compiling:
```
$ ./configure
```
Many configure options are provided, run `configure --help` for details. After
configuring the source tree, the code can be built and installed by running:
$ make && make install
The quality of MPI-RMA implementations varies. As of August, 2011 the
following MPI-2 implementations are known to work correctly with ARMCI-MPI:
* MPICH2 and MPICH 3+
* MVAPICH2 1.6
* Cray MPI on Cray XE6
* IBM MPI on BG/P (set `ARMCI_STRIDED_METHOD=IOV` and `ARMCI_IOV_METHOD=BATCHED` for _performance reasons_)
* OpenMPI 1.5.4 (set `ARMCI_STRIDED_METHOD=IOV` and `ARMCI_IOV_METHOD=BATCHED` for _correctness reasons_)
The following MPI-2 implementations are known to fail with ARMCI-MPI:
* MVAPICH2 prior to 1.6
As of April 2014, the following MPI-3 implementations are know to work correctly
with ARMCI-MPI (`mpi3rma` branch):
* MPICH 3.0.4 and later on Mac, Linux SMPs and SGI SMPs.
* MVAPICH2 2.0a and later on Linux InfiniBand clusters.
* CrayMPI 6.1.0 and later on Cray XC30.
* SGI MPT 2.09 on SGI SMPs.
* OpenMPI development version on Mac (set `ARMCI_STRIDED_METHOD=IOV` and `ARMCI_IOV_METHOD=BATCHED`)
Note that a bug in MPICH that propagated to MVAPICH2, Cray MPI and Intel MPI affects correctness
when windows are backed by shared-memory. This bug affects `ARMCI_Rmw` and is avoided with the
default settings, which use `MPI_Win_create`. This may negatively affect performance in some
cases and prevents one from using Casper. To utilize `MPI_Win_allocate`, do one of the following:
* Build with the `--enable-win-allocate` option to `configure`.
* Set `ARMCI_USE_WIN_ALLOCATE=1` in your runtime environment.
# Installing Global Arrays with ARMCI-MPI
ARMCI-MPI2 has been tested with GA 5.0.2. To build GA with ARMCI-MPI2, rename
this directory to "armci" and substitute it for the "armci" directory in the GA
distribution. Configure and build GA as usual; no special flags are required.
To build GA 5.2 with ARMCI-MPI (any version), use the configure option
`--with-armci=$(PATH_TO_ARMCI_MPI)` and make sure that you use the same MPI
implementation with GA that was used to compile ARMCI-MPI.
ARMCI-MPI3 has been tested extensively with GA 5.2 and 5.3.
# The ARMCI-MPI Test Suite
ARMCI-MPI includes a set of testing and benchmark programs located under `tests/`
and `benchmarks/`. These programs can be compiled and run via:
```
$ make check MPIEXEC="mpiexec -n 4"
```
The `MPIEXEC` variable is optional and is used to override the default MPI launch
command. If you want only to build the test suite, the following target can be
used:
```
$ make checkprogs
```
# ARMCI-MPI Errata
Direct access to local buffers:
* Because of MPI-2's semantics, you are not allowed to access shared memory
directly, it must be through put/get. Alternatively you can use the
new ARMCI_Access_begin/end() functions.
* MPI-3 allows direct access provided one uses a synchronization operation
afterwards. The ARMCI_Access_begin/end() functions are also valid.
Progress semantics:
* On some MPI implementations and networks you may need to enable implicit
progress. In many cases this is done through an environment variable. For
MPICH2: set `MPICH_ASYNC_PROGRESS`; for MVAPICH2 recompile with
`--enable-async-progress` and set `MPICH_ASYNC_PROGRESS`; set `DCMF_INTERRUPTS=1`
for MPI on BGP; etc.
See [this page](https://github.com/jeffhammond/HPCInfo/tree/master/mpi#asynchronous-progress)
for more information on activating asynchronous progress in MPI. However, we find
that most platforms show no improvement and often a decrease in performance,
provided the application makes calls to GA/ARMCI/MPI frequently enough on all
processes.
# Environment Variables:
Boolean environment variables are enabled when set to a value beginning with
't', 'T', 'y', 'Y', or '1'; any other value is interpreted as false.
##Debugging Options
ARMCI_VERBOSE (boolean)
Enable extra status output from ARMCI-MPI.
ARMCI_DEBUG_ALLOC (boolean)
Turn on extra shared allocation debugging.
ARMCI_FLUSH_BARRIERS (boolean) (deprecated)
Enable/disable extra communication flushing in ARMCI_Barrier. Extra flushes
are present to help make unsafe DLA safer. (This option is deprecated with
the ARMCI-MPI3 implementation.)
## Performance Options
ARMCI_CACHE_RANK_TRANSLATION (boolean)
Create a table to more quickly translate between absolute and group ranks.
ARMCI_PROGRESS_THREAD (boolean)
Create a Pthread to poke the MPI progress engine.
ARMCI_PROGRESS_USLEEP (int)
Argument to `usleep()` to pause the progress polling loop.
## Noncollective Groups
ARMCI_NONCOLLECTIVE_GROUPS (boolean)
Enable noncollective ARMCI group formation; group creation is collective on
the output group rather than the parent group.
## Shared Buffer Protection
ARMCI_SHR_BUF_METHOD = { COPY (default), NOGUARD }
ARMCI policy for managing shared origin buffers in communication operations:
lock the buffer (unsafe, but fast), copy the buffer (safe), or don't guard
the buffer - assume that the system is cache coherent and MPI supports
unlocked load/store.
## Strided Options
ARMCI_STRIDED_METHOD = { DIRECT (default), IOV }
Select the method for processing strided operations.
## I/O Vector Options
ARMCI_IOV_METHOD = { AUTO (default), CONSRV, BATCHED, DIRECT }
Select the IO vector communication strategy: automatic; a "conservative"
implementation that does lock/unlock around each operation; an implementation
that issues batches of operations within a single lock/unlock epoch; and a
direct implementation that generates datatypes for the origin and target and
issues a single operation using them.
ARMCI_IOV_CHECKS (boolean)
Enable (expensive) IOV safety/debugging checks (not recommended for
performance runs).
ARMCI_IOV_BATCHED_LIMIT = { 0 (default), 1, ... }
Set the maximum number of one-sided operations per epoch for the BATCHED IOV
method. Zero (default) is unlimited.
# Status
Right now, we are seeing failures caused by OpenMPI bugs, not because ARMCI-MPI itself is broken.
* `master`: [](https://travis-ci.org/jeffhammond/armci-mpi)
* `mpi2rma`: [](https://travis-ci.org/jeffhammond/armci-mpi)
* `mpi2rma-plus-rmw`: [](https://travis-ci.org/jeffhammond/armci-mpi)
* `mpi3rma`: [](https://travis-ci.org/jeffhammond/armci-mpi)
The `master` branch is still only for MPI-2 RMA.
The `mpi2rma` branch is essentially the same, except it is ABI-compatible with the MPI-3 branch.
The `mpi2rma-plus-rmw` uses mostly MPI-2 features except for MPI-3 atomics. Because it uses
MPI-2 RMA synchronization, it is _conservative_ and thus may work with an otherwise buggy
implementation of MPI-3 RMA. It exists primarily for historical purposes.
The `mpi3rma` branch is what one should use on the majority of platforms, provided MPI-3 RMA is working.
armci-mpi/autogen.sh 0000755 0001750 0001750 00000000127 12662706250 014213 0 ustar mbanck mbanck #! /bin/sh
autoreconf=${AUTORECONF:-autoreconf}
$autoreconf ${autoreconf_args:-"-vif"}
armci-mpi/.travis.yml 0000644 0001750 0001750 00000004057 12663426407 014335 0 ustar mbanck mbanck sudo: false
language: c
os:
# osx starts faster because homebrew installs beat building from source
- osx
- linux
compiler:
# nothing in ARMCI-MPI should be compiler-dependent,
# so test with the more strict of the two...
- clang
#- gcc
matrix:
allow_failures:
- env: MPI_IMPL=openmpi
- env: MPI_IMPL=openmpi
ARMCI_STRIDED_METHOD=DIRECT
ARMCI_IOV_METHOD=DIRECT
ARMCI_USE_WIN_ALLOCATE=0
env:
#
# MPICH
#
# with datatypes
- MPI_IMPL=mpich
ARMCI_STRIDED_METHOD=DIRECT
ARMCI_IOV_METHOD=DIRECT
ARMCI_USE_WIN_ALLOCATE=0
- MPI_IMPL=mpich
ARMCI_STRIDED_METHOD=DIRECT
ARMCI_IOV_METHOD=DIRECT
ARMCI_USE_WIN_ALLOCATE=1
# without datatypes
- MPI_IMPL=mpich
ARMCI_STRIDED_METHOD=IOV
ARMCI_IOV_METHOD=BATCHED
ARMCI_USE_WIN_ALLOCATE=0
- MPI_IMPL=mpich
ARMCI_STRIDED_METHOD=IOV
ARMCI_IOV_METHOD=BATCHED
ARMCI_USE_WIN_ALLOCATE=1
#
# Open-MPI
#
# with datatypes
- MPI_IMPL=openmpi
ARMCI_STRIDED_METHOD=DIRECT
ARMCI_IOV_METHOD=DIRECT
ARMCI_USE_WIN_ALLOCATE=0
- MPI_IMPL=openmpi
ARMCI_STRIDED_METHOD=DIRECT
ARMCI_IOV_METHOD=DIRECT
ARMCI_USE_WIN_ALLOCATE=1
# deal with ordering issue
- MPI_IMPL=openmpi
ARMCI_STRIDED_METHOD=DIRECT
ARMCI_IOV_METHOD=DIRECT
ARMCI_NO_FLUSH_LOCAL=1
ARMCI_USE_WIN_ALLOCATE=0
- MPI_IMPL=openmpi
ARMCI_STRIDED_METHOD=DIRECT
ARMCI_IOV_METHOD=DIRECT
ARMCI_NO_FLUSH_LOCAL=1
ARMCI_USE_WIN_ALLOCATE=1
# without datatypes
- MPI_IMPL=openmpi
ARMCI_STRIDED_METHOD=IOV
ARMCI_IOV_METHOD=BATCHED
ARMCI_USE_WIN_ALLOCATE=0
- MPI_IMPL=openmpi
ARMCI_STRIDED_METHOD=IOV
ARMCI_IOV_METHOD=BATCHED
ARMCI_USE_WIN_ALLOCATE=1
before_install:
- export TRAVIS_ROOT=$HOME/travis
- mkdir $TRAVIS_ROOT
- sh ./travis/install-autotools.sh $TRAVIS_ROOT
install:
- sh ./travis/install-mpi.sh $TRAVIS_ROOT $MPI_IMPL
script:
- sh ./travis/build-run.sh $TRAVIS_ROOT $MPI_IMPL
after_failure:
- cat ./config.log
- cat ./test-suite.log
- find . -name "*.log" -exec head -n 100 {} ";"
armci-mpi/COPYRIGHT 0000644 0001750 0001750 00000004557 12663426407 013524 0 ustar mbanck mbanck
The following is a notice of limited availability of the code, and disclaimer
which must be included in the prologue of the code and in all source listings
of the code.
Copyright (c) 2010-2013 Mathematics and Computer Science, Argonne National Laboratory
Copyright (c) 2010-2014 Argonne Leadership Computing Facility, Argonne National Laboratory
Copyright (c) 2010 Futures Laboratory, Oak Ridge National Laboratory
Copyright (c) 2014-2015 Intel Corporation
Permission is hereby granted to use, reproduce, prepare derivative works, and
to redistribute to others.
LICENSE
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
- Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
- Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer listed
in this license in the documentation and/or other materials
provided with the distribution.
- Neither the name of the copyright holders nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
The copyright holders provide no reassurances that the source code
provided does not infringe any patent, copyright, or any other
intellectual property rights of third parties. The copyright holders
disclaim any liability to any recipient for claims brought against
recipient by any third party for infringement of that parties
intellectual property rights.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
armci-mpi/Makefile.am 0000644 0001750 0001750 00000003437 12663426407 014261 0 ustar mbanck mbanck #
# Copyright (C) 2010. See COPYRIGHT in top-level directory.
#
ACLOCAL_AMFLAGS = -I m4
AM_CPPFLAGS = -I$(top_srcdir)/src
EXTRA_DIST = VERSION
lib_LTLIBRARIES = libarmci.la
# Needed to connect with the GA build system
noinst_LTLIBRARIES = libarmcii.la
libarmci_la_SOURCES = src/buffer.c \
src/debug.c \
src/groups.c \
src/internals.c \
src/malloc.c \
src/gmr.c \
src/gmr-extras.c \
src/message.c \
src/message_gop.c \
src/mutex.c \
src/mutex_hdl_queue.c \
src/onesided.c \
src/onesided_nb.c \
src/rmw.c \
src/strided.c \
src/strided_nb.c \
src/topology.c \
src/util.c \
src/value_ops.c \
src/vector.c \
src/vector_nb.c \
src/init_finalize.c \
src/conflict_tree.c \
src/parmci.c
libarmci_la_LDFLAGS = -version-info $(libarmci_abi_version)
libarmcii_la_SOURCES = $(libarmci_la_SOURCES)
libarmcii_la_LDFLAGS = $(libarmci_abi_version)
include_HEADERS = src/armciconf.h src/armci.h src/armci_internals.h src/armcix.h src/conflict_tree.h src/debug.h src/gmr.h src/message.h src/mp3.h
bin_PROGRAMS =
check_PROGRAMS =
TESTS =
XFAIL_TESTS =
MPIEXEC = mpiexec -n 2
LOG_COMPILER=$(MPIEXEC)
include benchmarks/Makefile.mk
include tests/Makefile.mk
.PHONY: checkprogs
checkprogs: $(check_PROGRAMS)
armci-mpi/configure.ac 0000644 0001750 0001750 00000015253 12663426407 014512 0 ustar mbanck mbanck dnl
dnl Copyright (C) 2010. See COPYRIGHT in top-level directory.
dnl
AC_PREREQ(2.62)
AC_INIT([armci],[0.1])
AC_CONFIG_AUX_DIR(m4)
AC_CONFIG_MACRO_DIR(m4)
AM_INIT_AUTOMAKE([-Wall -Werror foreign 1.11 color-tests parallel-tests subdir-objects])
LT_PREREQ([2.2.6])
## Bug in libtool adds -O2 and -g by default
if test ! -z "$MPICC" ; then
CC=$MPICC
export CC
fi
PAC_PUSH_FLAG(CFLAGS)
AC_PROG_CC(mpicc)
AM_PROG_CC_C_O
# automake 1.12 seems to require this, but automake 1.11 doesn't recognize it
# must come before LT_INIT
m4_ifdef([AM_PROG_AR],[AM_PROG_AR])
LT_INIT(disable-shared)
PAC_POP_FLAG(CFLAGS)
## Non-verbose make
m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES([yes])])
## Version checks
if test -s "$srcdir/VERSION" ; then
. $srcdir/VERSION
else
AC_MSG_ERROR([Version information not found. Configuration aborted.])
fi
ARMCI_VERSION=${PACKAGE_VERSION}
export ARMCI_VERSION
# ABI version
AC_SUBST(libarmci_abi_version)
# Release version
# Produce a numeric version assuming the following format:
# Version: [MAJ].[MIN].[REV][EXT][EXT_NUMBER]
# Example: 1.0.7rc1 has
# MAJ = 1
# MIN = 0
# REV = 7
# EXT = rc
# EXT_NUMBER = 1
#
# Converting to numeric version will convert EXT to a format number:
# ALPHA (a) = 0
# BETA (b) = 1
# RC (rc) = 2
# PATCH (p) = 3
# Regular releases are treated as patch 0
#
# Numeric version will have 1 digit for MAJ, 2 digits for MIN,
# 2 digits for REV, 1 digit for EXT and 2 digits for EXT_NUMBER.
changequote(<<,>>)
V1=`expr $ARMCI_VERSION : '\([0-9]*\)\.[0-9]*\.*[0-9]*[a-zA-Z]*[0-9]*'`
V2=`expr $ARMCI_VERSION : '[0-9]*\.\([0-9]*\)\.*[0-9]*[a-zA-Z]*[0-9]*'`
V3=`expr $ARMCI_VERSION : '[0-9]*\.[0-9]*\.*\([0-9]*\)[a-zA-Z]*[0-9]*'`
V4=`expr $ARMCI_VERSION : '[0-9]*\.[0-9]*\.*[0-9]*\([a-zA-Z]*\)[0-9]*'`
V5=`expr $ARMCI_VERSION : '[0-9]*\.[0-9]*\.*[0-9]*[a-zA-Z]*\([0-9]*\)'`
changequote([,])
if test "$V2" -le 9 ; then V2=0$V2 ; fi
if test "$V3" = "" ; then V3=0; fi
if test "$V3" -le 9 ; then V3=0$V3 ; fi
if test "$V4" = "a" ; then
V4=0
elif test "$V4" = "b" ; then
V4=1
elif test "$V4" = "rc" ; then
V4=2
elif test "$V4" = "" ; then
V4=3
V5=0
elif test "$V4" = "p" ; then
V4=3
fi
if test "$V5" -le 9 ; then V5=0$V5 ; fi
ARMCI_NUMVERSION=`expr $V1$V2$V3$V4$V5 + 0`
AC_SUBST(ARMCI_NUMVERSION)
AC_SUBST(ARMCI_VERSION)
AC_CONFIG_HEADER(src/armciconf.h)
AH_TOP([/* -*- Mode: C; c-basic-offset:4 ; -*- */
/*
* (C) 2010 by Argonne National Laboratory.
* See COPYRIGHT in top-level directory.
*/
#ifndef _ARMCICONF_H_
#define _ARMCICONF_H_
])
AH_BOTTOM([#endif /* _ARMCICONF_H_ */])
PAC_ARG_STRICT
PAC_CC_FUNCTION_NAME_SYMBOL
## Error checking functionality
#AC_ARG_ENABLE(error-checking,
#AC_HELP_STRING([--enable-error-checking],[Enable error checking functionality]),
#enable_error_checking=$enableval,
#enable_error_checking=yes)
#if test "$enable_error_checking" = "yes" ; then
#AC_DEFINE(ERROR_CHECKING,1,[Define if error checking is enabled])
#fi
## Check if __VA_ARGS__ is defined by the compiler
PAC_C_MACRO_VA_ARGS
## const and restrict
AC_C_CONST
AC_C_RESTRICT
## Check for C99
AC_PROG_CC_C99
if test "$ac_cv_prog_cc_c99" = "no" ; then
AC_ERROR([C99 not supported by the compiler])
fi
AC_CHECK_HEADERS([execinfo.h stdint.h inttypes.h unistd.h time.h])
AC_TYPE_UINT8_T
AX_PTHREAD([AC_DEFINE(HAVE_PTHREADS,1,[Defined when Pthread library is detected])])
CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
LIBS="$PTHREAD_LIBS $LIBS"
AC_CHECK_FUNC([usleep], [AC_DEFINE([HAVE_USLEEP], [1], [Define if usleep exists.])])
AC_CHECK_FUNC([nanosleep], [AC_DEFINE([HAVE_NANOSLEEP], [1], [Define if nanosleep exists.])])
## Debugging support
AC_ARG_ENABLE(g, AC_HELP_STRING([--enable-g],[Enable Debugging]),
[ debug=$enableval ],
[ debug=no ])
AC_MSG_CHECKING(debugging support)
AC_MSG_RESULT($debug)
if test "$debug" = "yes"; then
CFLAGS="$CFLAGS -g -O0"
fi
## Safety checks
AC_ARG_ENABLE(safety-checks, AC_HELP_STRING([--disable-safety-checks],[Disable safety checks for better performance]),
[ safety_enabled=$enableval ],
[ safety_enabled=yes ])
AC_MSG_CHECKING(whether safety checks are enabled)
AC_MSG_RESULT($safety_enabled)
if test "$safety_enabled" = "no"; then
AC_DEFINE(NO_SEATBELTS,1,[Defined when safety checks are disabled])
fi
## ARMCI Groups
AC_ARG_ENABLE(armci-group, AC_HELP_STRING([--enable-armci-group],[Enable ARMCI subset-collective group formation]),
[ armci_group_enabled=$enableval ],
[ armci_group_enabled=no ])
AC_MSG_CHECKING(whether ARMCI subset-collective group formation is enabled)
AC_MSG_RESULT($armci_group_enabled)
if test "$armci_group_enabled" = "yes"; then
AC_DEFINE(ARMCI_GROUP,1,[Defined when ARMCI subset-collective group formation is enabled])
fi
## Make explicit progress in nonblocking operations
AC_ARG_ENABLE(explicit-progress, AC_HELP_STRING([--enable-explicit-progress],[Enable explicit MPI progress during nonblocking calls]),
[ explicit_progress_enabled=$enableval ],
[ explicit_progress_enabled=no ])
AC_MSG_CHECKING(whether explicit MPI progress during nonblocking calls is enabled)
AC_MSG_RESULT($explicit_progress_enabled)
if test "$explicit_progress_enabled" = "yes"; then
AC_DEFINE(EXPLICIT_PROGRESS,1,[Defined when explicit MPI progress during nonblocking calls is enabled])
fi
## Active MPI_Win_allocate when we know it works
AC_ARG_ENABLE(win-allocate, AC_HELP_STRING([--enable-win-allocate],[Use MPI_WIN_ALLOCATE.]),
[ win_allocate_enabled=$enableval ],
[ win_allocate_enabled=no ])
AC_MSG_CHECKING(whether MPI_WIN_ALLOCATE will be used)
AC_MSG_RESULT($win_allocate_enabled)
if test "$win_allocate_enabled" = "yes"; then
AC_DEFINE(USE_WIN_ALLOCATE,1,[Defined when the use of MPI_WIN_ALLOCATE is enabled])
fi
# Check for support for weak symbols.
AC_ARG_ENABLE(weak-symbols, AC_HELP_STRING([--enable-weak-symbols],
[Use weak symbols to implement PARMCI routines (default)]),,
enable_weak_symbols=yes)
if test $enable_weak_symbols = yes ; then
# Turn off weak symbols if they aren't available
PAC_PROG_C_WEAK_SYMBOLS(,enable_weak_symbols=no)
fi
if test $enable_weak_symbols = "yes" ; then
AC_DEFINE(USE_WEAK_SYMBOLS,1,[Define if weak symbols should be used])
# Check for the ability to support multiple weak symbols
if test "$pac_cv_prog_c_weak_symbols" = "pragma weak" ; then
PAC_PROG_C_MULTIPLE_WEAK_SYMBOLS(AC_DEFINE(HAVE_MULTIPLE_PRAGMA_WEAK,1,[Define if multiple weak symbols may be defined]))
fi
fi
## Documentation
AC_PATH_PROG([DOXYGEN],[doxygen],,$PATH)
AC_SUBST(DOXYGEN)
AC_SUBST(top_srcdir)
## Final output
AC_OUTPUT(Makefile)
armci-mpi/src/ 0000755 0001750 0001750 00000000000 12663426407 013005 5 ustar mbanck mbanck armci-mpi/src/vector_nb.c 0000644 0001750 0001750 00000013110 12663426407 015126 0 ustar mbanck mbanck /*
* Copyright (C) 2010. See COPYRIGHT in top-level directory.
*/
#include
#include
#include
#include
#include
#include
/* -- begin weak symbols block -- */
#if defined(HAVE_PRAGMA_WEAK)
# pragma weak ARMCI_NbPutV = PARMCI_NbPutV
#elif defined(HAVE_PRAGMA_HP_SEC_DEF)
# pragma _HP_SECONDARY_DEF PARMCI_NbPutV ARMCI_NbPutV
#elif defined(HAVE_PRAGMA_CRI_DUP)
# pragma _CRI duplicate ARMCI_NbPutV as PARMCI_NbPutV
#endif
/* -- end weak symbols block -- */
/** Generalized I/O vector one-sided put.
*
* @param[in] iov Vector of transfer information.
* @param[in] iov_len Length of iov.
* @param[in] proc Target process.
* @return Success 0, otherwise non-zero.
*/
int PARMCI_NbPutV(armci_giov_t *iov, int iov_len, int proc, armci_hdl_t* handle) {
int v;
int blocking = 0;
if (ARMCII_GLOBAL_STATE.shr_buf_method != ARMCII_SHR_BUF_NOGUARD) {
blocking = 1;
}
for (v = 0; v < iov_len; v++) {
void **src_buf;
int overlapping, same_alloc;
if (iov[v].ptr_array_len == 0) continue; // NOP //
if (iov[v].bytes == 0) continue; // NOP //
overlapping = ARMCII_Iov_check_overlap(iov[v].dst_ptr_array, iov[v].ptr_array_len, iov[v].bytes);
same_alloc = ARMCII_Iov_check_same_allocation(iov[v].dst_ptr_array, iov[v].ptr_array_len, proc);
ARMCII_Buf_prepare_read_vec(iov[v].src_ptr_array, &src_buf, iov[v].ptr_array_len, iov[v].bytes);
ARMCII_Iov_op_dispatch(ARMCII_OP_PUT, src_buf, iov[v].dst_ptr_array, iov[v].ptr_array_len, iov[v].bytes, 0,
overlapping, same_alloc, proc, blocking);
ARMCII_Buf_finish_read_vec(iov[v].src_ptr_array, src_buf, iov[v].ptr_array_len, iov[v].bytes);
}
if (handle!=NULL) {
/* Regular (not aggregate) handles merely store the target for future flushing. */
handle->target = proc;
}
#ifdef EXPLICIT_PROGRESS
gmr_progress();
#endif
return 0;
}
/* -- begin weak symbols block -- */
#if defined(HAVE_PRAGMA_WEAK)
# pragma weak ARMCI_NbGetV = PARMCI_NbGetV
#elif defined(HAVE_PRAGMA_HP_SEC_DEF)
# pragma _HP_SECONDARY_DEF PARMCI_NbGetV ARMCI_NbGetV
#elif defined(HAVE_PRAGMA_CRI_DUP)
# pragma _CRI duplicate ARMCI_NbGetV as PARMCI_NbGetV
#endif
/* -- end weak symbols block -- */
/** Generalized I/O vector one-sided get.
*
* @param[in] iov Vector of transfer information.
* @param[in] iov_len Length of iov.
* @param[in] proc Target process.
* @return Success 0, otherwise non-zero.
*/
int PARMCI_NbGetV(armci_giov_t *iov, int iov_len, int proc, armci_hdl_t* handle) {
int v;
int blocking = 0;
if (ARMCII_GLOBAL_STATE.shr_buf_method != ARMCII_SHR_BUF_NOGUARD) {
blocking = 1;
}
for (v = 0; v < iov_len; v++) {
void **dst_buf;
int overlapping, same_alloc;
if (iov[v].ptr_array_len == 0) continue; // NOP //
if (iov[v].bytes == 0) continue; // NOP //
// overlapping = ARMCII_Iov_check_overlap(iov[v].src_ptr_array, iov[v].ptr_array_len, iov[v].bytes);
overlapping = ARMCII_Iov_check_overlap(iov[v].dst_ptr_array, iov[v].ptr_array_len, iov[v].bytes);
same_alloc = ARMCII_Iov_check_same_allocation(iov[v].src_ptr_array, iov[v].ptr_array_len, proc);
ARMCII_Buf_prepare_write_vec(iov[v].dst_ptr_array, &dst_buf, iov[v].ptr_array_len, iov[v].bytes);
ARMCII_Iov_op_dispatch(ARMCII_OP_GET, iov[v].src_ptr_array, dst_buf, iov[v].ptr_array_len, iov[v].bytes, 0,
overlapping, same_alloc, proc, blocking);
ARMCII_Buf_finish_write_vec(iov[v].dst_ptr_array, dst_buf, iov[v].ptr_array_len, iov[v].bytes);
}
if (handle!=NULL) {
/* Regular (not aggregate) handles merely store the target for future flushing. */
handle->target = proc;
}
#ifdef EXPLICIT_PROGRESS
gmr_progress();
#endif
return 0;
}
/* -- begin weak symbols block -- */
#if defined(HAVE_PRAGMA_WEAK)
# pragma weak ARMCI_NbAccV = PARMCI_NbAccV
#elif defined(HAVE_PRAGMA_HP_SEC_DEF)
# pragma _HP_SECONDARY_DEF PARMCI_NbAccV ARMCI_NbAccV
#elif defined(HAVE_PRAGMA_CRI_DUP)
# pragma _CRI duplicate ARMCI_NbAccV as PARMCI_NbAccV
#endif
/* -- end weak symbols block -- */
/** Generalized I/O vector one-sided accumulate.
*
* @param[in] iov Vector of transfer information.
* @param[in] iov_len Length of iov.
* @param[in] proc Target process.
* @return Success 0, otherwise non-zero.
*/
int PARMCI_NbAccV(int datatype, void *scale, armci_giov_t *iov, int iov_len, int proc, armci_hdl_t* handle) {
int v;
int blocking = 0;
if (ARMCII_GLOBAL_STATE.shr_buf_method != ARMCII_SHR_BUF_NOGUARD) {
blocking = 1;
}
for (v = 0; v < iov_len; v++) {
void **src_buf;
int overlapping, same_alloc;
if (iov[v].ptr_array_len == 0) continue; // NOP //
if (iov[v].bytes == 0) continue; // NOP //
overlapping = ARMCII_Iov_check_overlap(iov[v].dst_ptr_array, iov[v].ptr_array_len, iov[v].bytes);
same_alloc = ARMCII_Iov_check_same_allocation(iov[v].dst_ptr_array, iov[v].ptr_array_len, proc);
ARMCII_Buf_prepare_acc_vec(iov[v].src_ptr_array, &src_buf, iov[v].ptr_array_len, iov[v].bytes, datatype, scale);
ARMCII_Iov_op_dispatch(ARMCII_OP_ACC, src_buf, iov[v].dst_ptr_array, iov[v].ptr_array_len, iov[v].bytes, datatype,
overlapping, same_alloc, proc, blocking);
ARMCII_Buf_finish_acc_vec(iov[v].src_ptr_array, src_buf, iov[v].ptr_array_len, iov[v].bytes);
}
if (handle!=NULL) {
/* Regular (not aggregate) handles merely store the target for future flushing. */
handle->target = proc;
}
#ifdef EXPLICIT_PROGRESS
gmr_progress();
#endif
return 0;
}
armci-mpi/src/debug.c 0000644 0001750 0001750 00000004433 12662706250 014237 0 ustar mbanck mbanck /*
* Copyright (C) 2010. See COPYRIGHT in top-level directory.
*/
#include
#include
#include
#include
#include
#include
/* Set the default debugging message classes to enable.
*/
unsigned DEBUG_CATS_ENABLED =
DEBUG_CAT_NONE;
// DEBUG_CAT_ALL;
// DEBUG_CAT_ALLOC;
// DEBUG_CAT_ALLOC | DEBUG_CAT_MEM_REGION;
// DEBUG_CAT_MUTEX;
// DEBUG_CAT_GROUPS;
/** Print an assertion failure message and abort the program.
*/
void ARMCII_Assert_fail(const char *expr, const char *msg, const char *file, int line, const char *func) {
int rank;
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
if (msg == NULL)
fprintf(stderr, "[%d] ARMCI assert fail in %s() [%s:%d]: \"%s\"\n", rank, func, file, line, expr);
else
fprintf(stderr, "[%d] ARMCI assert fail in %s() [%s:%d]: \"%s\"\n"
"[%d] Message: \"%s\"\n", rank, func, file, line, expr, rank, msg);
#if HAVE_EXECINFO_H
{
#include
const int SIZE = 100;
int j, nframes;
void *frames[SIZE];
char **symbols;
nframes = backtrace(frames, SIZE);
symbols = backtrace_symbols(frames, nframes);
if (symbols == NULL)
perror("Backtrace failure");
fprintf(stderr, "[%d] Backtrace:\n", rank);
for (j = 0; j < nframes; j++)
fprintf(stderr, "[%d] %2d - %s\n", rank, nframes-j-1, symbols[j]);
free(symbols);
}
#endif
fflush(NULL);
{
double stall = MPI_Wtime();
while (MPI_Wtime() - stall < 1) ;
}
MPI_Abort(MPI_COMM_WORLD, -1);
}
/** Print a debugging message.
*/
void ARMCII_Dbg_print_impl(const char *func, const char *format, ...) {
va_list etc;
int disp;
char string[500];
disp = 0;
disp += snprintf(string, 500, "[%d] %s: ", ARMCI_GROUP_WORLD.rank, func);
va_start(etc, format);
disp += vsnprintf(string+disp, 500-disp, format, etc);
va_end(etc);
fprintf(stderr, "%s", string);
}
/** Print an ARMCI warning message.
*/
void ARMCII_Warning(const char *fmt, ...) {
va_list etc;
int disp;
char string[500];
disp = 0;
disp += snprintf(string, 500, "[%d] ARMCI Warning: ", ARMCI_GROUP_WORLD.rank);
va_start(etc, fmt);
disp += vsnprintf(string+disp, 500-disp, fmt, etc);
va_end(etc);
fprintf(stderr, "%s", string);
fflush(NULL);
}
armci-mpi/src/mp3.fh 0000644 0001750 0001750 00000000247 12662706250 014022 0 ustar mbanck mbanck #include "mpif.h"
#define MP_TIMER() mpi_wtime()
#define MP_FINALIZE() mpi_finalize(ierr)
#ifndef MP_DEFINES_ONLY
integer ierr
call mpi_init(ierr)
#endif
armci-mpi/src/mp3def.fh 0000644 0001750 0001750 00000000101 12662706250 014466 0 ustar mbanck mbanck #define MP_DEFINES_ONLY
#include "mp3.fh"
#undef MP_DEFINES_ONLY
armci-mpi/src/strided.c 0000644 0001750 0001750 00000060214 12663426407 014612 0 ustar mbanck mbanck /*
* Copyright (C) 2010. See COPYRIGHT in top-level directory.
*/
#include
#include
#include
#include
#include
#include
#include
/** Convert an ARMCI strided access description into an MPI subarray datatype.
*
* @param[in] stride_array Array of strides
* @param[in] count Array of transfer counts
* @param[in] stride_levels Number of levels of striding
* @param[in] old_type Type of the data element described by count and stride_array
* @param[out] new_type New MPI type for the given strided access
*/
void ARMCII_Strided_to_dtype(int stride_array[/*stride_levels*/], int count[/*stride_levels+1*/],
int stride_levels, MPI_Datatype old_type, MPI_Datatype *new_type)
{
int sizes [stride_levels+1];
int subsizes[stride_levels+1];
int starts [stride_levels+1];
int i, old_type_size;
MPI_Type_size(old_type, &old_type_size);
/* Eliminate counts that don't count (all 1 counts at the end) */
for (i = stride_levels+1; (i > 0) && (stride_levels > 0) && (count[i-1] == 1); i--)
stride_levels--;
/* A correct strided spec should me monotonic increasing and stride_array[i+1] should
be a multiple of stride_array[i]. */
if (stride_levels > 0) {
for (i = 1; i < stride_levels; i++) {
ARMCII_Assert(stride_array[i] >= stride_array[i-1]);
/* This assertion is violated by what seems to be valid usage resulting from
* the new GA API call nga_strided_get during the stride test in GA 5.2.
* ARMCII_Assert((stride_array[i] % stride_array[i-1]) == 0); */
}
}
/* Test for a contiguous transfer */
if (stride_levels == 0) {
int elem_count = count[0]/old_type_size;
ARMCII_Assert((count[0] % old_type_size) == 0);
MPI_Type_contiguous(elem_count, old_type, new_type);
}
/* Transfer is non-contiguous */
else {
for (i = 0; i < stride_levels+1; i++)
starts[i] = 0;
sizes [stride_levels] = stride_array[0]/old_type_size;
subsizes[stride_levels] = count[0]/old_type_size;
ARMCII_Assert((stride_array[0] % old_type_size) == 0);
ARMCII_Assert((count[0] % old_type_size) == 0);
for (i = 1; i < stride_levels; i++) {
/* Convert strides into dimensions by dividing out contributions from lower dims */
sizes [stride_levels-i] = stride_array[i]/stride_array[i-1];
subsizes[stride_levels-i] = count[i];
/* This assertion is violated by what seems to be valid usage resulting from
* the new GA API call nga_strided_get during the stride test in GA 5.2.
* ARMCII_Assert_msg((stride_array[i] % stride_array[i-1]) == 0, "Invalid striding"); */
}
sizes [0] = count[stride_levels];
subsizes[0] = count[stride_levels];
MPI_Type_create_subarray(stride_levels+1, sizes, subsizes, starts, MPI_ORDER_C, old_type, new_type);
}
}
/* -- begin weak symbols block -- */
#if defined(HAVE_PRAGMA_WEAK)
# pragma weak ARMCI_PutS = PARMCI_PutS
#elif defined(HAVE_PRAGMA_HP_SEC_DEF)
# pragma _HP_SECONDARY_DEF PARMCI_PutS ARMCI_PutS
#elif defined(HAVE_PRAGMA_CRI_DUP)
# pragma _CRI duplicate ARMCI_PutS as PARMCI_PutS
#endif
/* -- end weak symbols block -- */
/** Blocking operation that transfers data from the calling process to the
* memory of the remote process. The data transfer is strided and blocking.
*
* @param[in] src_ptr Source starting address of the data block to put.
* @param[in] src_stride_arr Source array of stride distances in bytes.
* @param[in] dst_ptr Destination starting address to put data.
* @param[in] dst_stride_ar Destination array of stride distances in bytes.
* @param[in] count Block size in each dimension. count[0] should be the
* number of bytes of contiguous data in leading dimension.
* @param[in] stride_levels The level of strides.
* @param[in] proc Remote process ID (destination).
*
* @return Zero on success, error code otherwise.
*/
int PARMCI_PutS(void *src_ptr, int src_stride_ar[/*stride_levels*/],
void *dst_ptr, int dst_stride_ar[/*stride_levels*/],
int count[/*stride_levels+1*/], int stride_levels, int proc) {
int err;
if (ARMCII_GLOBAL_STATE.strided_method == ARMCII_STRIDED_DIRECT) {
void *src_buf = NULL;
gmr_t *mreg, *gmr_loc = NULL;
MPI_Datatype src_type, dst_type;
/* COPY: Guard shared buffers */
if (ARMCII_GLOBAL_STATE.shr_buf_method == ARMCII_SHR_BUF_COPY) {
gmr_loc = gmr_lookup(src_ptr, ARMCI_GROUP_WORLD.rank);
if (gmr_loc != NULL) {
int i, size;
for (i = 1, size = count[0]; i < stride_levels+1; i++)
size *= count[i];
MPI_Alloc_mem(size, MPI_INFO_NULL, &src_buf);
ARMCII_Assert(src_buf != NULL);
armci_write_strided(src_ptr, stride_levels, src_stride_ar, count, src_buf);
MPI_Type_contiguous(size, MPI_BYTE, &src_type);
}
}
else {
/* Jeff: WIN_UNIFIED should allow overlap to work but we
* do a memory barrier here to be safe. */
gmr_loc = gmr_lookup(src_ptr, ARMCI_GROUP_WORLD.rank);
gmr_sync(gmr_loc);
}
/* NOGUARD: If src_buf hasn't been assigned to a copy, the strided source
* buffer is going to be used directly. */
if (src_buf == NULL) {
src_buf = src_ptr;
ARMCII_Strided_to_dtype(src_stride_ar, count, stride_levels, MPI_BYTE, &src_type);
}
ARMCII_Strided_to_dtype(dst_stride_ar, count, stride_levels, MPI_BYTE, &dst_type);
MPI_Type_commit(&src_type);
MPI_Type_commit(&dst_type);
mreg = gmr_lookup(dst_ptr, proc);
ARMCII_Assert_msg(mreg != NULL, "Invalid shared pointer");
gmr_put_typed(mreg, src_buf, 1, src_type, dst_ptr, 1, dst_type, proc);
gmr_flush(mreg, proc, 1); /* flush_local */
MPI_Type_free(&src_type);
MPI_Type_free(&dst_type);
/* COPY: Free temporary buffer */
if (src_buf != src_ptr) {
MPI_Free_mem(src_buf);
}
err = 0;
} else {
armci_giov_t iov;
ARMCII_Strided_to_iov(&iov, src_ptr, src_stride_ar, dst_ptr, dst_stride_ar, count, stride_levels);
err = PARMCI_PutV(&iov, 1, proc);
free(iov.src_ptr_array);
free(iov.dst_ptr_array);
}
return err;
}
/* -- begin weak symbols block -- */
#if defined(HAVE_PRAGMA_WEAK)
# pragma weak ARMCI_GetS = PARMCI_GetS
#elif defined(HAVE_PRAGMA_HP_SEC_DEF)
# pragma _HP_SECONDARY_DEF PARMCI_GetS ARMCI_GetS
#elif defined(HAVE_PRAGMA_CRI_DUP)
# pragma _CRI duplicate ARMCI_GetS as PARMCI_GetS
#endif
/* -- end weak symbols block -- */
/** Blocking operation that transfers data from the remote process to the
* memory of the calling process. The data transfer is strided and blocking.
*
* @param[in] src_ptr Source starting address of the data block to put.
* @param[in] src_stride_arr Source array of stride distances in bytes.
* @param[in] dst_ptr Destination starting address to put data.
* @param[in] dst_stride_ar Destination array of stride distances in bytes.
* @param[in] count Block size in each dimension. count[0] should be the
* number of bytes of contiguous data in leading dimension.
* @param[in] stride_levels The level of strides.
* @param[in] proc Remote process ID (destination).
*
* @return Zero on success, error code otherwise.
*/
int PARMCI_GetS(void *src_ptr, int src_stride_ar[/*stride_levels*/],
void *dst_ptr, int dst_stride_ar[/*stride_levels*/],
int count[/*stride_levels+1*/], int stride_levels, int proc) {
int err;
if (ARMCII_GLOBAL_STATE.strided_method == ARMCII_STRIDED_DIRECT) {
void *dst_buf = NULL;
gmr_t *mreg, *gmr_loc = NULL;
MPI_Datatype src_type, dst_type;
/* COPY: Guard shared buffers */
if (ARMCII_GLOBAL_STATE.shr_buf_method == ARMCII_SHR_BUF_COPY) {
gmr_loc = gmr_lookup(dst_ptr, ARMCI_GROUP_WORLD.rank);
if (gmr_loc != NULL) {
int i, size;
for (i = 1, size = count[0]; i < stride_levels+1; i++)
size *= count[i];
MPI_Alloc_mem(size, MPI_INFO_NULL, &dst_buf);
ARMCII_Assert(dst_buf != NULL);
MPI_Type_contiguous(size, MPI_BYTE, &dst_type);
}
}
else {
/* Jeff: WIN_UNIFIED should allow overlap to work but we
* do a memory barrier here to be safe. */
gmr_loc = gmr_lookup(dst_ptr, ARMCI_GROUP_WORLD.rank);
gmr_sync(gmr_loc);
}
/* NOGUARD: If dst_buf hasn't been assigned to a copy, the strided source
* buffer is going to be used directly. */
if (dst_buf == NULL) {
dst_buf = dst_ptr;
ARMCII_Strided_to_dtype(dst_stride_ar, count, stride_levels, MPI_BYTE, &dst_type);
}
ARMCII_Strided_to_dtype(src_stride_ar, count, stride_levels, MPI_BYTE, &src_type);
MPI_Type_commit(&src_type);
MPI_Type_commit(&dst_type);
mreg = gmr_lookup(src_ptr, proc);
ARMCII_Assert_msg(mreg != NULL, "Invalid shared pointer");
gmr_get_typed(mreg, src_ptr, 1, src_type, dst_buf, 1, dst_type, proc);
gmr_flush(mreg, proc, 0);
/* COPY: Finish the transfer */
if (dst_buf != dst_ptr) {
armci_read_strided(dst_ptr, stride_levels, dst_stride_ar, count, dst_buf);
MPI_Free_mem(dst_buf);
}
MPI_Type_free(&src_type);
MPI_Type_free(&dst_type);
err = 0;
} else {
armci_giov_t iov;
ARMCII_Strided_to_iov(&iov, src_ptr, src_stride_ar, dst_ptr, dst_stride_ar, count, stride_levels);
err = PARMCI_GetV(&iov, 1, proc);
free(iov.src_ptr_array);
free(iov.dst_ptr_array);
}
return err;
}
/* -- begin weak symbols block -- */
#if defined(HAVE_PRAGMA_WEAK)
# pragma weak ARMCI_AccS = PARMCI_AccS
#elif defined(HAVE_PRAGMA_HP_SEC_DEF)
# pragma _HP_SECONDARY_DEF PARMCI_AccS ARMCI_AccS
#elif defined(HAVE_PRAGMA_CRI_DUP)
# pragma _CRI duplicate ARMCI_AccS as PARMCI_AccS
#endif
/* -- end weak symbols block -- */
/** Blocking operation that accumulates data from the local process into the
* memory of the remote process. The data transfer is strided and blocking.
*
* @param[in] datatype Type of data to be transferred.
* @param[in] scale Pointer to the value that input data should be scaled by.
* @param[in] src_ptr Source starting address of the data block to put.
* @param[in] src_stride_arr Source array of stride distances in bytes.
* @param[in] dst_ptr Destination starting address to put data.
* @param[in] dst_stride_ar Destination array of stride distances in bytes.
* @param[in] count Block size in each dimension. count[0] should be the
* number of bytes of contiguous data in leading dimension.
* @param[in] stride_levels The level of strides.
* @param[in] proc Remote process ID (destination).
*
* @return Zero on success, error code otherwise.
*/
int PARMCI_AccS(int datatype, void *scale,
void *src_ptr, int src_stride_ar[/*stride_levels*/],
void *dst_ptr, int dst_stride_ar[/*stride_levels*/],
int count[/*stride_levels+1*/], int stride_levels, int proc) {
int err;
if (ARMCII_GLOBAL_STATE.strided_method == ARMCII_STRIDED_DIRECT) {
void *src_buf = NULL;
gmr_t *mreg, *gmr_loc = NULL;
MPI_Datatype src_type, dst_type, mpi_datatype;
int scaled, mpi_datatype_size;
int src_size, dst_size;
ARMCII_Acc_type_translate(datatype, &mpi_datatype, &mpi_datatype_size);
scaled = ARMCII_Buf_acc_is_scaled(datatype, scale);
/* SCALE: copy and scale if requested */
if (scaled) {
armci_giov_t iov;
int i, nelem;
if (ARMCII_GLOBAL_STATE.shr_buf_method != ARMCII_SHR_BUF_NOGUARD)
gmr_loc = gmr_lookup(src_ptr, ARMCI_GROUP_WORLD.rank);
for (i = 1, nelem = count[0]/mpi_datatype_size; i < stride_levels+1; i++)
nelem *= count[i];
MPI_Alloc_mem(nelem*mpi_datatype_size, MPI_INFO_NULL, &src_buf);
ARMCII_Assert(src_buf != NULL);
/* Shoehorn the strided information into an IOV */
ARMCII_Strided_to_iov(&iov, src_ptr, src_stride_ar, src_ptr, src_stride_ar, count, stride_levels);
for (i = 0; i < iov.ptr_array_len; i++)
ARMCII_Buf_acc_scale(iov.src_ptr_array[i], ((uint8_t*)src_buf) + i*iov.bytes, iov.bytes, datatype, scale);
free(iov.src_ptr_array);
free(iov.dst_ptr_array);
MPI_Type_contiguous(nelem, mpi_datatype, &src_type);
}
/* COPY: Guard shared buffers */
else if (ARMCII_GLOBAL_STATE.shr_buf_method == ARMCII_SHR_BUF_COPY) {
gmr_loc = gmr_lookup(src_ptr, ARMCI_GROUP_WORLD.rank);
if (gmr_loc != NULL) {
int i, nelem;
for (i = 1, nelem = count[0]/mpi_datatype_size; i < stride_levels+1; i++)
nelem *= count[i];
MPI_Alloc_mem(nelem*mpi_datatype_size, MPI_INFO_NULL, &src_buf);
ARMCII_Assert(src_buf != NULL);
armci_write_strided(src_ptr, stride_levels, src_stride_ar, count, src_buf);
MPI_Type_contiguous(nelem, mpi_datatype, &src_type);
}
}
else {
/* Jeff: WIN_UNIFIED should allow overlap to work but we
* do a memory barrier here to be safe. */
gmr_loc = gmr_lookup(src_ptr, ARMCI_GROUP_WORLD.rank);
gmr_sync(gmr_loc);
}
/* NOGUARD: If src_buf hasn't been assigned to a copy, the strided source
* buffer is going to be used directly. */
if (src_buf == NULL) {
src_buf = src_ptr;
ARMCII_Strided_to_dtype(src_stride_ar, count, stride_levels, mpi_datatype, &src_type);
}
ARMCII_Strided_to_dtype(dst_stride_ar, count, stride_levels, mpi_datatype, &dst_type);
MPI_Type_commit(&src_type);
MPI_Type_commit(&dst_type);
MPI_Type_size(src_type, &src_size);
MPI_Type_size(dst_type, &dst_size);
ARMCII_Assert(src_size == dst_size);
mreg = gmr_lookup(dst_ptr, proc);
ARMCII_Assert_msg(mreg != NULL, "Invalid shared pointer");
gmr_accumulate_typed(mreg, src_buf, 1, src_type, dst_ptr, 1, dst_type, proc);
gmr_flush(mreg, proc, 1); /* flush_local */
MPI_Type_free(&src_type);
MPI_Type_free(&dst_type);
/* COPY/SCALE: Free temp buffer */
if (src_buf != src_ptr) {
MPI_Free_mem(src_buf);
}
err = 0;
} else {
armci_giov_t iov;
ARMCII_Strided_to_iov(&iov, src_ptr, src_stride_ar, dst_ptr, dst_stride_ar, count, stride_levels);
err = PARMCI_AccV(datatype, scale, &iov, 1, proc);
free(iov.src_ptr_array);
free(iov.dst_ptr_array);
}
return err;
}
/** Translate a strided operation into a more general IO Vector.
*
* @param[in] src_ptr Source starting address of the data block to put.
* @param[in] src_stride_arr Source array of stride distances in bytes.
* @param[in] dst_ptr Destination starting address to put data.
* @param[in] dst_stride_ar Destination array of stride distances in bytes.
* @param[in] count Block size in each dimension. count[0] should be the
* number of bytes of contiguous data in leading dimension.
* @param[in] stride_levels The level of strides.
*
* @return Zero on success, error code otherwise.
*/
void ARMCII_Strided_to_iov(armci_giov_t *iov,
void *src_ptr, int src_stride_ar[/*stride_levels*/],
void *dst_ptr, int dst_stride_ar[/*stride_levels*/],
int count[/*stride_levels+1*/], int stride_levels) {
int i;
iov->bytes = count[0];
iov->ptr_array_len = 1;
for (i = 0; i < stride_levels; i++)
iov->ptr_array_len *= count[i+1];
iov->src_ptr_array = malloc(iov->ptr_array_len*sizeof(void*));
iov->dst_ptr_array = malloc(iov->ptr_array_len*sizeof(void*));
ARMCII_Assert((iov->src_ptr_array != NULL) && (iov->dst_ptr_array != NULL));
// Case 1: Non-strided transfer
if (stride_levels == 0) {
iov->src_ptr_array[0] = src_ptr;
iov->dst_ptr_array[0] = dst_ptr;
// Case 2: Strided transfer
} else {
int idx[stride_levels];
int xfer;
for (i = 0; i < stride_levels; i++)
idx[i] = 0;
for (xfer = 0; idx[stride_levels-1] < count[stride_levels]; xfer++) {
int disp_src = 0;
int disp_dst = 0;
ARMCII_Assert(xfer < iov->ptr_array_len);
// Calculate displacements from base pointers
for (i = 0; i < stride_levels; i++) {
disp_src += src_stride_ar[i]*idx[i];
disp_dst += dst_stride_ar[i]*idx[i];
}
// Add to the IO Vector
iov->src_ptr_array[xfer] = ((uint8_t*)src_ptr) + disp_src;
iov->dst_ptr_array[xfer] = ((uint8_t*)dst_ptr) + disp_dst;
// Increment innermost index
idx[0] += 1;
// Propagate "carry" overflows outward. We're done when the outermost
// index is greater than the requested count.
for (i = 0; i < stride_levels-1; i++) {
if (idx[i] >= count[i+1]) {
idx[i] = 0;
idx[i+1] += 1;
}
}
}
ARMCII_Assert(xfer == iov->ptr_array_len);
}
}
/** Translate a strided operation into a more general IO Vector iterator.
*
* @param[in] src_ptr Source starting address of the data block to put.
* @param[in] src_stride_arr Source array of stride distances in bytes.
* @param[in] dst_ptr Destination starting address to put data.
* @param[in] dst_stride_ar Destination array of stride distances in bytes.
* @param[in] count Block size in each dimension. count[0] should be the
* number of bytes of contiguous data in leading dimension.
* @param[in] stride_levels The level of strides.
*
* @return ARMCI IOV iterator corresponding to the strided parameters.
*/
armcii_iov_iter_t *ARMCII_Strided_to_iov_iter(
void *src_ptr, int src_stride_ar[/*stride_levels*/],
void *dst_ptr, int dst_stride_ar[/*stride_levels*/],
int count[/*stride_levels+1*/], int stride_levels) {
int i;
armcii_iov_iter_t *it = malloc(sizeof(armcii_iov_iter_t));
ARMCII_Assert(it != NULL);
it->src = src_ptr;
it->dst = dst_ptr;
it->stride_levels = stride_levels;
it->base_ptr = malloc(sizeof(int)*(4*stride_levels+1));
it->was_contiguous= 0;
ARMCII_Assert( it->base_ptr != NULL );
it->src_stride_ar = &it->base_ptr[0*stride_levels];
it->dst_stride_ar = &it->base_ptr[1*stride_levels];
it->count = &it->base_ptr[2*stride_levels];
it->idx = &it->base_ptr[3*stride_levels+1];
for (i = 0; i < stride_levels; i++) {
it->src_stride_ar[i] = src_stride_ar[i];
it->dst_stride_ar[i] = dst_stride_ar[i];
it->count[i] = count[i];
it->idx[i] = 0;
}
return it;
}
/** Free an iterator.
*
* @param[in] it IOV iterator
*/
void ARMCII_Iov_iter_free(armcii_iov_iter_t *it) {
free(it->base_ptr);
free(it);
}
/** Query whether the iterator has another iteration.
*
* @param[in] it IOV iterator
*
* @return True if another iteration exists
*/
int ARMCII_Iov_iter_has_next(armcii_iov_iter_t *it) {
return ((it->idx[it->stride_levels-1] < it->count[it->stride_levels]) && (!it->was_contiguous));
}
/** Get the next source/destination pointer pair from the IOV iterator.
*
* @param[in] it IOV iterator
* @param[out] src Source adress
* @param[out] dst Destination adress
*
* @return True if another iteration existed
*/
int ARMCII_Iov_iter_next(armcii_iov_iter_t *it, void **src, void **dst) {
if (!ARMCII_Iov_iter_has_next(it)) {
*src = NULL;
*dst = NULL;
return 0;
}
// Case 1: Non-strided transfer
if (it->stride_levels == 0) {
*src = src;
*dst = dst;
it->was_contiguous = 1;
// Case 2: Strided transfer
} else {
int i, disp_src = 0, disp_dst = 0;
// Calculate displacements from base pointers
for (i = 0; i < it->stride_levels; i++) {
disp_src += it->src_stride_ar[i]*it->idx[i];
disp_dst += it->dst_stride_ar[i]*it->idx[i];
}
// Add to the IO Vector
*src = ((uint8_t*)it->src) + disp_src;
*dst = ((uint8_t*)it->dst) + disp_dst;
// Increment innermost index
it->idx[0] += 1;
// Propagate "carry" overflows outward. We're done when the outermost
// index is greater than the requested count.
for (i = 0; i < it->stride_levels-1; i++) {
if (it->idx[i] >= it->count[i+1]) {
it->idx[i] = 0;
it->idx[i+1] += 1;
}
}
}
return 1;
}
/* -- begin weak symbols block -- */
#if defined(HAVE_PRAGMA_WEAK)
# pragma weak ARMCI_PutS_flag = PARMCI_PutS_flag
#elif defined(HAVE_PRAGMA_HP_SEC_DEF)
# pragma _HP_SECONDARY_DEF PARMCI_PutS_flag ARMCI_PutS_flag
#elif defined(HAVE_PRAGMA_CRI_DUP)
# pragma _CRI duplicate ARMCI_PutS_flag as PARMCI_PutS_flag
#endif
/* -- end weak symbols block -- */
/** Blocking operation that transfers data from the calling process to the
* memory of the remote process. The data transfer is strided and blocking.
* After the transfer completes, the given flag is set on the remote process.
*
* @param[in] src_ptr Source starting address of the data block to put.
* @param[in] src_stride_arr Source array of stride distances in bytes.
* @param[in] dst_ptr Destination starting address to put data.
* @param[in] dst_stride_ar Destination array of stride distances in bytes.
* @param[in] count Block size in each dimension. count[0] should be the
* number of bytes of contiguous data in leading dimension.
* @param[in] stride_levels The level of strides.
* @param[in] flag Location of the flag buffer
* @param[in] value Value to set the flag to
* @param[in] proc Remote process ID (destination).
*
* @return Zero on success, error code otherwise.
*/
int PARMCI_PutS_flag(void *src_ptr, int src_stride_ar[/*stride_levels*/],
void *dst_ptr, int dst_stride_ar[/*stride_levels*/],
int count[/*stride_levels+1*/], int stride_levels,
int *flag, int value, int proc) {
/* TODO: This can be optimized with a more direct implementation, especially in the
* case where RMA is ordered; in that case, the Fence (Flush) is not necessary. */
PARMCI_PutS(src_ptr, src_stride_ar, dst_ptr, dst_stride_ar, count, stride_levels, proc);
PARMCI_Fence(proc);
PARMCI_Put(&value, flag, sizeof(int), proc);
return 1;
}
/* Pack strided data into a contiguous destination buffer. This is a local operation.
*
* @param[in] src Pointer to the strided buffer
* @param[in] stride_levels Number of levels of striding
* @param[in] src_stride_arr Array of length stride_levels of stride lengths
* @param[in] count Array of length stride_levels+1 of the number of
* units at each stride level (lowest is contiguous)
* @param[in] dst Destination contiguous buffer
*/
void armci_write_strided(void *src, int stride_levels, int src_stride_arr[],
int count[], char *dst) {
armci_giov_t iov;
int i;
// Shoehorn the strided information into an IOV
ARMCII_Strided_to_iov(&iov, src, src_stride_arr, src, src_stride_arr, count, stride_levels);
for (i = 0; i < iov.ptr_array_len; i++)
ARMCI_Copy(iov.src_ptr_array[i], dst + i*count[0], iov.bytes);
free(iov.src_ptr_array);
free(iov.dst_ptr_array);
}
/* Unpack strided data from a contiguous source buffer. This is a local operation.
*
* @param[in] src Pointer to the contiguous buffer
* @param[in] stride_levels Number of levels of striding
* @param[in] dst_stride_arr Array of length stride_levels of stride lengths
* @param[in] count Array of length stride_levels+1 of the number of
* units at each stride level (lowest is contiguous)
* @param[in] dst Destination strided buffer
*/
void armci_read_strided(void *dst, int stride_levels, int dst_stride_arr[],
int count[], char *src) {
armci_giov_t iov;
int i;
// Shoehorn the strided information into an IOV
ARMCII_Strided_to_iov(&iov, dst, dst_stride_arr, dst, dst_stride_arr, count, stride_levels);
for (i = 0; i < iov.ptr_array_len; i++)
ARMCI_Copy(src + i*count[0], iov.dst_ptr_array[i], iov.bytes);
free(iov.src_ptr_array);
free(iov.dst_ptr_array);
}
armci-mpi/src/value_ops.c 0000644 0001750 0001750 00000014266 12662706250 015153 0 ustar mbanck mbanck /*
* Copyright (C) 2010. See COPYRIGHT in top-level directory.
*/
#include
#include
#include
#include
/* Put value operations */
/* -- begin weak symbols block -- */
#if defined(HAVE_PRAGMA_WEAK)
# pragma weak ARMCI_PutValueInt = PARMCI_PutValueInt
#elif defined(HAVE_PRAGMA_HP_SEC_DEF)
# pragma _HP_SECONDARY_DEF PARMCI_PutValueInt ARMCI_PutValueInt
#elif defined(HAVE_PRAGMA_CRI_DUP)
# pragma _CRI duplicate ARMCI_PutValueInt as PARMCI_PutValueInt
#endif
/* -- end weak symbols block -- */
int PARMCI_PutValueInt(int src, void *dst, int proc) {
return PARMCI_Put(&src, dst, sizeof(int), proc);
}
/* -- begin weak symbols block -- */
#if defined(HAVE_PRAGMA_WEAK)
# pragma weak ARMCI_PutValueLong = PARMCI_PutValueLong
#elif defined(HAVE_PRAGMA_HP_SEC_DEF)
# pragma _HP_SECONDARY_DEF PARMCI_PutValueLong ARMCI_PutValueLong
#elif defined(HAVE_PRAGMA_CRI_DUP)
# pragma _CRI duplicate ARMCI_PutValueLong as PARMCI_PutValueLong
#endif
/* -- end weak symbols block -- */
int PARMCI_PutValueLong(long src, void *dst, int proc) {
return PARMCI_Put(&src, dst, sizeof(long), proc);
}
/* -- begin weak symbols block -- */
#if defined(HAVE_PRAGMA_WEAK)
# pragma weak ARMCI_PutValueFloat = PARMCI_PutValueFloat
#elif defined(HAVE_PRAGMA_HP_SEC_DEF)
# pragma _HP_SECONDARY_DEF PARMCI_PutValueFloat ARMCI_PutValueFloat
#elif defined(HAVE_PRAGMA_CRI_DUP)
# pragma _CRI duplicate ARMCI_PutValueFloat as PARMCI_PutValueFloat
#endif
/* -- end weak symbols block -- */
int PARMCI_PutValueFloat(float src, void *dst, int proc) {
return PARMCI_Put(&src, dst, sizeof(float), proc);
}
/* -- begin weak symbols block -- */
#if defined(HAVE_PRAGMA_WEAK)
# pragma weak ARMCI_PutValueDouble = PARMCI_PutValueDouble
#elif defined(HAVE_PRAGMA_HP_SEC_DEF)
# pragma _HP_SECONDARY_DEF PARMCI_PutValueDouble ARMCI_PutValueDouble
#elif defined(HAVE_PRAGMA_CRI_DUP)
# pragma _CRI duplicate ARMCI_PutValueDouble as PARMCI_PutValueDouble
#endif
/* -- end weak symbols block -- */
int PARMCI_PutValueDouble(double src, void *dst, int proc) {
return PARMCI_Put(&src, dst, sizeof(double), proc);
}
/* Non-blocking put operations */
/* -- begin weak symbols block -- */
#if defined(HAVE_PRAGMA_WEAK)
# pragma weak ARMCI_NbPutValueInt = PARMCI_NbPutValueInt
#elif defined(HAVE_PRAGMA_HP_SEC_DEF)
# pragma _HP_SECONDARY_DEF PARMCI_NbPutValueInt ARMCI_NbPutValueInt
#elif defined(HAVE_PRAGMA_CRI_DUP)
# pragma _CRI duplicate ARMCI_NbPutValueInt as PARMCI_NbPutValueInt
#endif
/* -- end weak symbols block -- */
int PARMCI_NbPutValueInt(int src, void *dst, int proc, armci_hdl_t *hdl) {
return PARMCI_NbPut(&src, dst, sizeof(int), proc, hdl);
}
/* -- begin weak symbols block -- */
#if defined(HAVE_PRAGMA_WEAK)
# pragma weak ARMCI_NbPutValueLong = PARMCI_NbPutValueLong
#elif defined(HAVE_PRAGMA_HP_SEC_DEF)
# pragma _HP_SECONDARY_DEF PARMCI_NbPutValueLong ARMCI_NbPutValueLong
#elif defined(HAVE_PRAGMA_CRI_DUP)
# pragma _CRI duplicate ARMCI_NbPutValueLong as PARMCI_NbPutValueLong
#endif
/* -- end weak symbols block -- */
int PARMCI_NbPutValueLong(long src, void *dst, int proc, armci_hdl_t *hdl) {
return PARMCI_NbPut(&src, dst, sizeof(long), proc, hdl);
}
/* -- begin weak symbols block -- */
#if defined(HAVE_PRAGMA_WEAK)
# pragma weak ARMCI_NbPutValueFloat = PARMCI_NbPutValueFloat
#elif defined(HAVE_PRAGMA_HP_SEC_DEF)
# pragma _HP_SECONDARY_DEF PARMCI_NbPutValueFloat ARMCI_NbPutValueFloat
#elif defined(HAVE_PRAGMA_CRI_DUP)
# pragma _CRI duplicate ARMCI_NbPutValueFloat as PARMCI_NbPutValueFloat
#endif
/* -- end weak symbols block -- */
int PARMCI_NbPutValueFloat(float src, void *dst, int proc, armci_hdl_t *hdl) {
return PARMCI_NbPut(&src, dst, sizeof(float), proc, hdl);
}
/* -- begin weak symbols block -- */
#if defined(HAVE_PRAGMA_WEAK)
# pragma weak ARMCI_NbPutValueDouble = PARMCI_NbPutValueDouble
#elif defined(HAVE_PRAGMA_HP_SEC_DEF)
# pragma _HP_SECONDARY_DEF PARMCI_NbPutValueDouble ARMCI_NbPutValueDouble
#elif defined(HAVE_PRAGMA_CRI_DUP)
# pragma _CRI duplicate ARMCI_NbPutValueDouble as PARMCI_NbPutValueDouble
#endif
/* -- end weak symbols block -- */
int PARMCI_NbPutValueDouble(double src, void *dst, int proc, armci_hdl_t *hdl) {
return PARMCI_NbPut(&src, dst, sizeof(double), proc, hdl);
}
/* Get value operations */
/* -- begin weak symbols block -- */
#if defined(HAVE_PRAGMA_WEAK)
# pragma weak ARMCI_GetValueInt = PARMCI_GetValueInt
#elif defined(HAVE_PRAGMA_HP_SEC_DEF)
# pragma _HP_SECONDARY_DEF PARMCI_GetValueInt ARMCI_GetValueInt
#elif defined(HAVE_PRAGMA_CRI_DUP)
# pragma _CRI duplicate ARMCI_GetValueInt as PARMCI_GetValueInt
#endif
/* -- end weak symbols block -- */
int PARMCI_GetValueInt(void *src, int proc) {
int val;
PARMCI_Get(src, &val, sizeof(int), proc);
return val;
}
/* -- begin weak symbols block -- */
#if defined(HAVE_PRAGMA_WEAK)
# pragma weak ARMCI_GetValueLong = PARMCI_GetValueLong
#elif defined(HAVE_PRAGMA_HP_SEC_DEF)
# pragma _HP_SECONDARY_DEF PARMCI_GetValueLong ARMCI_GetValueLong
#elif defined(HAVE_PRAGMA_CRI_DUP)
# pragma _CRI duplicate ARMCI_GetValueLong as PARMCI_GetValueLong
#endif
/* -- end weak symbols block -- */
long PARMCI_GetValueLong(void *src, int proc) {
long val;
PARMCI_Get(src, &val, sizeof(long), proc);
return val;
}
/* -- begin weak symbols block -- */
#if defined(HAVE_PRAGMA_WEAK)
# pragma weak ARMCI_GetValueFloat = PARMCI_GetValueFloat
#elif defined(HAVE_PRAGMA_HP_SEC_DEF)
# pragma _HP_SECONDARY_DEF PARMCI_GetValueFloat ARMCI_GetValueFloat
#elif defined(HAVE_PRAGMA_CRI_DUP)
# pragma _CRI duplicate ARMCI_GetValueFloat as PARMCI_GetValueFloat
#endif
/* -- end weak symbols block -- */
float PARMCI_GetValueFloat(void *src, int proc) {
float val;
PARMCI_Get(src, &val, sizeof(float), proc);
return val;
}
/* -- begin weak symbols block -- */
#if defined(HAVE_PRAGMA_WEAK)
# pragma weak ARMCI_GetValueDouble = PARMCI_GetValueDouble
#elif defined(HAVE_PRAGMA_HP_SEC_DEF)
# pragma _HP_SECONDARY_DEF PARMCI_GetValueDouble ARMCI_GetValueDouble
#elif defined(HAVE_PRAGMA_CRI_DUP)
# pragma _CRI duplicate ARMCI_GetValueDouble as PARMCI_GetValueDouble
#endif
/* -- end weak symbols block -- */
double PARMCI_GetValueDouble(void *src, int proc) {
double val;
PARMCI_Get(src, &val, sizeof(double), proc);
return val;
}
armci-mpi/src/mutex_hdl_queue.c 0000644 0001750 0001750 00000014756 12662706250 016357 0 ustar mbanck mbanck /*
* Copyright (C) 2010. See COPYRIGHT in top-level directory.
*/
#include
#include
#include
#include
#include
#include
#include
#define ARMCI_MUTEX_TAG 100
/* TODO: Make these all no-ops for sequential runs */
/** Create a group of ARMCI mutexes. Collective onthe ARMCI group.
*
* @param[in] count Number of mutexes on the local process.
* @param[in] pgroup ARMCI group on which to create mutexes
* @return Handle to the mutex group.
*/
armcix_mutex_hdl_t ARMCIX_Create_mutexes_hdl(int my_count, ARMCI_Group *pgroup) {
int rank, nproc, max_count, i;
armcix_mutex_hdl_t hdl;
hdl = malloc(sizeof(struct armcix_mutex_hdl_s));
ARMCII_Assert(hdl != NULL);
ARMCIX_Group_dup(pgroup, &hdl->grp);
MPI_Comm_rank(hdl->grp.comm, &rank);
MPI_Comm_size(hdl->grp.comm, &nproc);
hdl->my_count = my_count;
/* Find the max. count to determine how many windows we need. */
MPI_Allreduce(&my_count, &max_count, 1, MPI_INT, MPI_MAX, hdl->grp.comm);
ARMCII_Assert_msg(max_count > 0, "Invalid number of mutexes");
hdl->max_count = max_count;
hdl->windows = malloc(sizeof(MPI_Win)*max_count);
if (my_count > 0) {
hdl->bases = malloc(sizeof(uint8_t*)*my_count);
} else {
hdl->bases = NULL;
}
/* We need multiple windows here: one for each mutex. Otherwise
performance will suffer due to exclusive access epochs. */
for (i = 0; i < max_count; i++) {
int size = 0;
void *base = NULL;
if (i < my_count) {
MPI_Alloc_mem(nproc, MPI_INFO_NULL, &hdl->bases[i]);
ARMCII_Assert(hdl->bases[i] != NULL);
ARMCII_Bzero(hdl->bases[i], nproc);
base = hdl->bases[i];
size = nproc;
}
MPI_Win_create(base, size, sizeof(uint8_t), MPI_INFO_NULL, hdl->grp.comm, &hdl->windows[i]);
}
return hdl;
}
/** Destroy a group of ARMCI mutexes. Collective.
*
* @param[in] hdl Handle to the group that should be destroyed.
* @return Zero on success, non-zero otherwise.
*/
int ARMCIX_Destroy_mutexes_hdl(armcix_mutex_hdl_t hdl) {
int i;
for (i = 0; i < hdl->max_count; i++) {
MPI_Win_free(&hdl->windows[i]);
}
if (hdl->bases != NULL) {
for (i = 0; i < hdl->my_count; i++)
MPI_Free_mem(hdl->bases[i]);
free(hdl->bases);
}
ARMCI_Group_free(&hdl->grp);
free(hdl->windows);
free(hdl);
return 0;
}
/** Lock a mutex.
*
* @param[in] hdl Mutex group that the mutex belongs to.
* @param[in] mutex Desired mutex number [0..count-1]
* @param[in] world_proc Absolute ID of process where the mutex lives
*/
void ARMCIX_Lock_hdl(armcix_mutex_hdl_t hdl, int mutex, int world_proc) {
int rank, nproc, already_locked, i, proc;
uint8_t *buf;
ARMCII_Assert(mutex >= 0 && mutex < hdl->max_count);
MPI_Comm_rank(hdl->grp.comm, &rank);
MPI_Comm_size(hdl->grp.comm, &nproc);
/* User gives us the absolute ID. Translate to the rank in the mutex's group. */
proc = ARMCII_Translate_absolute_to_group(&hdl->grp, world_proc);
ARMCII_Assert(proc >= 0);
buf = malloc(nproc*sizeof(uint8_t));
ARMCII_Assert(buf != NULL);
buf[rank] = 1;
/* Get all data from the lock_buf, except the byte belonging to
* me. Set the byte belonging to me to 1. */
MPI_Win_lock(MPI_LOCK_EXCLUSIVE, proc, 0, hdl->windows[mutex]);
MPI_Put(&buf[rank], 1, MPI_BYTE, proc, rank, 1, MPI_BYTE, hdl->windows[mutex]);
/* Get data to the left of rank */
if (rank > 0) {
MPI_Get(buf, rank, MPI_BYTE, proc, 0, rank, MPI_BYTE, hdl->windows[mutex]);
}
/* Get data to the right of rank */
if (rank < nproc - 1) {
MPI_Get(&buf[rank+1], nproc-1-rank, MPI_BYTE, proc, rank + 1, nproc-1-rank, MPI_BYTE, hdl->windows[mutex]);
}
MPI_Win_unlock(proc, hdl->windows[mutex]);
ARMCII_Assert(buf[rank] == 1);
for (i = already_locked = 0; i < nproc; i++)
if (buf[i] && i != rank)
already_locked = 1;
/* Wait for notification */
if (already_locked) {
MPI_Status status;
ARMCII_Dbg_print(DEBUG_CAT_MUTEX, "waiting for notification [proc = %d, mutex = %d]\n", proc, mutex);
MPI_Recv(NULL, 0, MPI_BYTE, MPI_ANY_SOURCE, ARMCI_MUTEX_TAG+mutex, hdl->grp.comm, &status);
}
ARMCII_Dbg_print(DEBUG_CAT_MUTEX, "lock acquired [proc = %d, mutex = %d]\n", proc, mutex);
free(buf);
}
/** Attempt to lock a mutex (implemented as a blocking call).
*
* @param[in] hdl Mutex group that the mutex belongs to.
* @param[in] mutex Desired mutex number [0..count-1]
* @param[in] world_proc Absolute ID of process where the mutex lives
* @return 0 on success, non-zero on failure
*/
int ARMCIX_Trylock_hdl(armcix_mutex_hdl_t hdl, int mutex, int world_proc) {
ARMCII_Assert(mutex >= 0 && mutex < hdl->max_count);
ARMCIX_Lock_hdl(hdl, mutex, world_proc);
return 0;
}
/** Unlock a mutex.
*
* @param[in] hdl Mutex group that the mutex belongs to.
* @param[in] mutex Desired mutex number [0..count-1]
* @param[in] world_proc Absolute ID of process where the mutex lives
*/
void ARMCIX_Unlock_hdl(armcix_mutex_hdl_t hdl, int mutex, int world_proc) {
int rank, nproc, i, proc;
uint8_t *buf;
ARMCII_Assert(mutex >= 0 && mutex < hdl->max_count);
MPI_Comm_rank(hdl->grp.comm, &rank);
MPI_Comm_size(hdl->grp.comm, &nproc);
proc = ARMCII_Translate_absolute_to_group(&hdl->grp, world_proc);
ARMCII_Assert(proc >= 0);
buf = malloc(nproc*sizeof(uint8_t));
buf[rank] = 0;
/* Get all data from the lock_buf, except the byte belonging to
* me. Set the byte belonging to me to 0. */
MPI_Win_lock(MPI_LOCK_EXCLUSIVE, proc, 0, hdl->windows[mutex]);
MPI_Put(&buf[rank], 1, MPI_BYTE, proc, rank, 1, MPI_BYTE, hdl->windows[mutex]);
/* Get data to the left of rank */
if (rank > 0) {
MPI_Get(buf, rank, MPI_BYTE, proc, 0, rank, MPI_BYTE, hdl->windows[mutex]);
}
/* Get data to the right of rank */
if (rank < nproc - 1) {
MPI_Get(&buf[rank+1], nproc-1-rank, MPI_BYTE, proc, rank + 1, nproc-1-rank, MPI_BYTE, hdl->windows[mutex]);
}
MPI_Win_unlock(proc, hdl->windows[mutex]);
ARMCII_Assert(buf[rank] == 0);
/* Notify the next waiting process, starting to my right for fairness */
for (i = 1; i < nproc; i++) {
int p = (rank + i) % nproc;
if (buf[p] == 1) {
ARMCII_Dbg_print(DEBUG_CAT_MUTEX, "notifying %d [proc = %d, mutex = %d]\n", p, proc, mutex);
MPI_Send(NULL, 0, MPI_BYTE, p, ARMCI_MUTEX_TAG+mutex, hdl->grp.comm);
break;
}
}
ARMCII_Dbg_print(DEBUG_CAT_MUTEX, "lock released [proc = %d, mutex = %d]\n", proc, mutex);
free(buf);
}
armci-mpi/src/vector.c 0000644 0001750 0001750 00000036557 12663426407 014473 0 ustar mbanck mbanck /*
* Copyright (C) 2010. See COPYRIGHT in top-level directory.
*/
#include
#include
#include
#include
#include
#include
#ifndef NO_USE_CTREE
#include
#endif
/** Check an I/O vector operation's buffers for overlap.
*
* @param[in] iov Vector of transfer information.
* @return Logical true when regions overlap, 0 otherwise.
*/
int ARMCII_Iov_check_overlap(void **ptrs, int count, int size) {
#ifndef NO_CHECK_OVERLAP
#ifdef NO_USE_CTREE
int i, j;
if (!ARMCII_GLOBAL_STATE.iov_checks) return 0;
for (i = 0; i < count; i++) {
for (j = i+1; j < count; j++) {
const uint8_t *ptr_1_lo = ptrs[i];
const uint8_t *ptr_1_hi = ((uint8_t*)ptrs[i]) + size - 1;
const uint8_t *ptr_2_lo = ptrs[j];
const uint8_t *ptr_2_hi = ((uint8_t*)ptrs[j]) + size - 1;
if ( (ptr_1_lo >= ptr_2_lo && ptr_1_lo <= ptr_2_hi)
|| (ptr_1_hi >= ptr_2_lo && ptr_1_hi <= ptr_2_hi)
|| (ptr_1_lo < ptr_2_lo && ptr_1_hi > ptr_2_hi)) {
ARMCII_Dbg_print(DEBUG_CAT_IOV, "IOV regions overlap: [%p, %p] - [%p, %p]\n",
ptr_1_lo, ptr_1_hi, ptr_2_lo, ptr_2_hi);
return 1;
}
}
}
#else
int i;
ctree_t ctree = CTREE_EMPTY;
if (!ARMCII_GLOBAL_STATE.iov_checks) return 0;
for (i = 0; i < count; i++) {
int conflict = ctree_insert(&ctree, ptrs[i], ((uint8_t*)ptrs[i]) + size - 1);
if (conflict) {
ctree_t cnode = ctree_locate(ctree, ptrs[i], ((uint8_t*)ptrs[i]) + size - 1);
ARMCII_Dbg_print(DEBUG_CAT_IOV, "IOV regions overlap: [%p, %p] - [%p, %p]\n",
ptrs[i], ((uint8_t*)ptrs[i]) + size - 1, cnode->lo, cnode->hi);
ctree_destroy(&ctree);
return 1;
}
}
ctree_destroy(&ctree);
#endif /* NO_USE_CTREE */
#endif /* NO_CHECK_OVERLAP */
return 0;
}
/** Check if a set of pointers all corresponds to the same allocation.
*
* @param[in] ptrs An array of count shared pointers valid on proc.
* @param[in] count Size of the ptrs array.
* @param[in] proc Process on which the pointers are valid.
* @return Non-zero (true) on success, zero (false) otherwise.
*/
int ARMCII_Iov_check_same_allocation(void **ptrs, int count, int proc) {
int i;
gmr_t *mreg;
void *base, *extent;
if (!ARMCII_GLOBAL_STATE.iov_checks) return 1;
mreg = gmr_lookup(ptrs[0], proc);
/* If local, all must be local */
if (mreg == NULL) {
for (i = 1; i < count; i++) {
mreg = gmr_lookup(ptrs[i], proc);
if (mreg != NULL)
return 0;
}
}
/* If shared, all must fall in this region */
else {
base = mreg->slices[proc].base;
extent = ((uint8_t*) base) + mreg->slices[proc].size;
for (i = 1; i < count; i++)
if ( !(ptrs[i] >= base && ptrs[i] < extent) )
return 0;
}
return 1;
}
/** Perform an I/O vector operation. Local buffers must be private.
*
* @param[in] op Operation to be performed (ARMCII_OP_PUT, ...)
* @param[in] src Array of source pointers
* @param[in] dst Array of destination pointers
* @param[in] count Length of pointer arrays
* @param[in] size Size of each transfer
* @param[in] datatype Data type for accumulate op (ignored for all others)
* @param[in] overlapping Do remote regions overlap?
* @param[in] same_alloc Do remote regions correspond to the same allocation?
* @param[in] proc Target process
* @return Zero on success, error code otherwise
*/
int ARMCII_Iov_op_dispatch(enum ARMCII_Op_e op, void **src, void **dst, int count, int size,
int datatype, int overlapping, int same_alloc, int proc, int blocking) {
MPI_Datatype type;
int type_count, type_size;
if (op == ARMCII_OP_ACC) {
ARMCII_Acc_type_translate(datatype, &type, &type_size);
type_count = size/type_size;
ARMCII_Assert_msg(size % type_size == 0, "Transfer size is not a multiple of type size");
} else {
type = MPI_BYTE;
MPI_Type_size(type, &type_size);
type_count = size/type_size;
ARMCII_Assert_msg(size % type_size == 0, "Transfer size is not a multiple of type size");
}
// CONSERVATIVE CASE: If remote pointers overlap or remote pointers correspond to
// multiple allocations, use the safe implementation to avoid invalid MPI
// use.
if (overlapping || !same_alloc || ARMCII_GLOBAL_STATE.iov_method == ARMCII_IOV_CONSRV) {
if (overlapping) ARMCII_Warning("IOV remote buffers overlap\n");
if (!same_alloc) ARMCII_Warning("IOV remote buffers are not within the same allocation\n");
#if 0
return ARMCII_Iov_op_safe(op, src, dst, count, type_count, type, proc);
#else
/* Jeff: We are going to always block when there is buffer overlap. */
return ARMCII_Iov_op_batched(op, src, dst, count, type_count, type, proc, 1 /* consrv */, 1 /* blocking */);
#endif
}
// OPTIMIZED CASE: It's safe for us to issue all the operations under a
// single lock.
else if ( ARMCII_GLOBAL_STATE.iov_method == ARMCII_IOV_DIRECT
|| ARMCII_GLOBAL_STATE.iov_method == ARMCII_IOV_AUTO ) {
return ARMCII_Iov_op_datatype(op, src, dst, count, type_count, type, proc, blocking);
} else if (ARMCII_GLOBAL_STATE.iov_method == ARMCII_IOV_BATCHED) {
return ARMCII_Iov_op_batched(op, src, dst, count, type_count, type, proc, 0 /* not consrv */, blocking);
} else {
ARMCII_Error("unknown iov method (%d)\n", ARMCII_GLOBAL_STATE.iov_method);
return 1;
}
}
#if 0
/** Safe implementation of the ARMCI IOV operation
*/
int ARMCII_Iov_op_safe(enum ARMCII_Op_e op, void **src, void **dst, int count, int elem_count,
MPI_Datatype type, int proc) {
int i;
int flush_local = 0; /* used only for MPI-3 */
for (i = 0; i < count; i++) {
gmr_t *mreg;
void *shr_ptr;
switch(op) {
case ARMCII_OP_ACC:
case ARMCII_OP_PUT:
shr_ptr = dst[i];
break;
case ARMCII_OP_GET:
shr_ptr = src[i];
break;
default:
ARMCII_Error("unknown operation (%d)", op);
return 1;
}
mreg = gmr_lookup(shr_ptr, proc);
ARMCII_Assert_msg(mreg != NULL, "Invalid remote pointer");
switch(op) {
case ARMCII_OP_PUT:
gmr_put(mreg, src[i], dst[i], elem_count, proc);
flush_local = 1;
break;
case ARMCII_OP_GET:
gmr_get(mreg, src[i], dst[i], elem_count, proc);
flush_local = 0;
break;
case ARMCII_OP_ACC:
gmr_accumulate(mreg, src[i], dst[i], elem_count, type, proc);
flush_local = 1;
break;
default:
ARMCII_Error("unknown operation (%d)", op);
return 1;
}
gmr_flush(mreg, proc, flush_local);
}
return 0;
}
#endif
/** Optimized implementation of the ARMCI IOV operation that uses a single
* lock/unlock pair.
*/
int ARMCII_Iov_op_batched(enum ARMCII_Op_e op, void **src, void **dst, int count, int elem_count,
MPI_Datatype type, int proc, int consrv, int blocking) {
int i;
int flush_local = 1; /* used only for MPI-3 */
gmr_t *mreg;
void *shr_ptr;
switch(op) {
case ARMCII_OP_ACC:
case ARMCII_OP_PUT:
shr_ptr = dst[0];
break;
case ARMCII_OP_GET:
shr_ptr = src[0];
break;
default:
ARMCII_Error("unknown operation (%d)", op);
return 1;
}
mreg = gmr_lookup(shr_ptr, proc);
ARMCII_Assert_msg(mreg != NULL, "Invalid remote pointer");
for (i = 0; i < count; i++) {
if ( blocking && i > 0 &&
( consrv ||
( ARMCII_GLOBAL_STATE.iov_batched_limit > 0 && i % ARMCII_GLOBAL_STATE.iov_batched_limit == 0)
)
)
{
gmr_flush(mreg, proc, flush_local);
}
switch(op) {
case ARMCII_OP_PUT:
gmr_put(mreg, src[i], dst[i], elem_count, proc);
flush_local = 1;
break;
case ARMCII_OP_GET:
gmr_get(mreg, src[i], dst[i], elem_count, proc);
flush_local = 0;
break;
case ARMCII_OP_ACC:
gmr_accumulate(mreg, src[i], dst[i], elem_count, type, proc);
flush_local = 1;
break;
default:
ARMCII_Error("unknown operation (%d)", op);
return 1;
}
}
if (blocking) {
gmr_flush(mreg, proc, flush_local);
}
return 0;
}
/** Optimized implementation of the ARMCI IOV operation that uses an MPI
* datatype to achieve a one-sided gather/scatter.
*/
int ARMCII_Iov_op_datatype(enum ARMCII_Op_e op, void **src, void **dst, int count, int elem_count,
MPI_Datatype type, int proc, int blocking) {
gmr_t *mreg;
MPI_Datatype type_loc, type_rem;
MPI_Aint disp_loc[count];
int disp_rem[count];
int block_len[count];
void *dst_win_base;
int dst_win_size, i, type_size;
void **buf_rem, **buf_loc;
MPI_Aint base_rem;
int flush_local = 0; /* used only for MPI-3 */
switch(op) {
case ARMCII_OP_ACC:
case ARMCII_OP_PUT:
buf_rem = dst;
buf_loc = src;
break;
case ARMCII_OP_GET:
buf_rem = src;
buf_loc = dst;
break;
default:
ARMCII_Error("unknown operation (%d)", op);
return 1;
}
MPI_Type_size(type, &type_size);
mreg = gmr_lookup(buf_rem[0], proc);
ARMCII_Assert_msg(mreg != NULL, "Invalid remote pointer");
dst_win_base = mreg->slices[proc].base;
dst_win_size = mreg->slices[proc].size;
MPI_Get_address(dst_win_base, &base_rem);
for (i = 0; i < count; i++) {
MPI_Aint target_rem;
MPI_Get_address(buf_loc[i], &disp_loc[i]);
MPI_Get_address(buf_rem[i], &target_rem);
disp_rem[i] = (target_rem - base_rem)/type_size;
block_len[i] = elem_count;
ARMCII_Assert_msg((target_rem - base_rem) % type_size == 0, "Transfer size is not a multiple of type size");
ARMCII_Assert_msg(disp_rem[i] >= 0 && disp_rem[i] < dst_win_size, "Invalid remote pointer");
ARMCII_Assert_msg(((uint8_t*)buf_rem[i]) + block_len[i] <= ((uint8_t*)dst_win_base) + dst_win_size, "Transfer exceeds buffer length");
}
MPI_Type_create_hindexed(count, block_len, disp_loc, type, &type_loc);
MPI_Type_create_indexed_block(count, elem_count, disp_rem, type, &type_rem);
/* MPI_Type_create_indexed_block should be more efficient than this:
MPI_Type_indexed(count, block_len, disp_rem, type, &type_rem); */
MPI_Type_commit(&type_loc);
MPI_Type_commit(&type_rem);
switch(op) {
case ARMCII_OP_PUT:
gmr_put_typed(mreg, MPI_BOTTOM, 1, type_loc, MPI_BOTTOM, 1, type_rem, proc);
flush_local = 1;
break;
case ARMCII_OP_GET:
gmr_get_typed(mreg, MPI_BOTTOM, 1, type_rem, MPI_BOTTOM, 1, type_loc, proc);
flush_local = 0;
break;
case ARMCII_OP_ACC:
gmr_accumulate_typed(mreg, MPI_BOTTOM, 1, type_loc, MPI_BOTTOM, 1, type_rem, proc);
flush_local = 1;
break;
default:
ARMCII_Error("unknown operation (%d)", op);
return 1;
}
if (blocking) {
gmr_flush(mreg, proc, flush_local);
}
MPI_Type_free(&type_loc);
MPI_Type_free(&type_rem);
return 0;
}
/* -- begin weak symbols block -- */
#if defined(HAVE_PRAGMA_WEAK)
# pragma weak ARMCI_PutV = PARMCI_PutV
#elif defined(HAVE_PRAGMA_HP_SEC_DEF)
# pragma _HP_SECONDARY_DEF PARMCI_PutV ARMCI_PutV
#elif defined(HAVE_PRAGMA_CRI_DUP)
# pragma _CRI duplicate ARMCI_PutV as PARMCI_PutV
#endif
/* -- end weak symbols block -- */
/** Generalized I/O vector one-sided put.
*
* @param[in] iov Vector of transfer information.
* @param[in] iov_len Length of iov.
* @param[in] proc Target process.
* @return Success 0, otherwise non-zero.
*/
int PARMCI_PutV(armci_giov_t *iov, int iov_len, int proc) {
int v;
for (v = 0; v < iov_len; v++) {
void **src_buf;
int overlapping, same_alloc;
if (iov[v].ptr_array_len == 0) continue; // NOP //
if (iov[v].bytes == 0) continue; // NOP //
overlapping = ARMCII_Iov_check_overlap(iov[v].dst_ptr_array, iov[v].ptr_array_len, iov[v].bytes);
same_alloc = ARMCII_Iov_check_same_allocation(iov[v].dst_ptr_array, iov[v].ptr_array_len, proc);
ARMCII_Buf_prepare_read_vec(iov[v].src_ptr_array, &src_buf, iov[v].ptr_array_len, iov[v].bytes);
ARMCII_Iov_op_dispatch(ARMCII_OP_PUT, src_buf, iov[v].dst_ptr_array, iov[v].ptr_array_len, iov[v].bytes, 0,
overlapping, same_alloc, proc, 1 /* blocking */);
ARMCII_Buf_finish_read_vec(iov[v].src_ptr_array, src_buf, iov[v].ptr_array_len, iov[v].bytes);
}
return 0;
}
/* -- begin weak symbols block -- */
#if defined(HAVE_PRAGMA_WEAK)
# pragma weak ARMCI_GetV = PARMCI_GetV
#elif defined(HAVE_PRAGMA_HP_SEC_DEF)
# pragma _HP_SECONDARY_DEF PARMCI_GetV ARMCI_GetV
#elif defined(HAVE_PRAGMA_CRI_DUP)
# pragma _CRI duplicate ARMCI_GetV as PARMCI_GetV
#endif
/* -- end weak symbols block -- */
/** Generalized I/O vector one-sided get.
*
* @param[in] iov Vector of transfer information.
* @param[in] iov_len Length of iov.
* @param[in] proc Target process.
* @return Success 0, otherwise non-zero.
*/
int PARMCI_GetV(armci_giov_t *iov, int iov_len, int proc) {
int v;
for (v = 0; v < iov_len; v++) {
void **dst_buf;
int overlapping, same_alloc;
if (iov[v].ptr_array_len == 0) continue; // NOP //
if (iov[v].bytes == 0) continue; // NOP //
// overlapping = ARMCII_Iov_check_overlap(iov[v].src_ptr_array, iov[v].ptr_array_len, iov[v].bytes);
overlapping = ARMCII_Iov_check_overlap(iov[v].dst_ptr_array, iov[v].ptr_array_len, iov[v].bytes);
same_alloc = ARMCII_Iov_check_same_allocation(iov[v].src_ptr_array, iov[v].ptr_array_len, proc);
ARMCII_Buf_prepare_write_vec(iov[v].dst_ptr_array, &dst_buf, iov[v].ptr_array_len, iov[v].bytes);
ARMCII_Iov_op_dispatch(ARMCII_OP_GET, iov[v].src_ptr_array, dst_buf, iov[v].ptr_array_len, iov[v].bytes, 0,
overlapping, same_alloc, proc, 1 /* blocking */);
ARMCII_Buf_finish_write_vec(iov[v].dst_ptr_array, dst_buf, iov[v].ptr_array_len, iov[v].bytes);
}
return 0;
}
/* -- begin weak symbols block -- */
#if defined(HAVE_PRAGMA_WEAK)
# pragma weak ARMCI_AccV = PARMCI_AccV
#elif defined(HAVE_PRAGMA_HP_SEC_DEF)
# pragma _HP_SECONDARY_DEF PARMCI_AccV ARMCI_AccV
#elif defined(HAVE_PRAGMA_CRI_DUP)
# pragma _CRI duplicate ARMCI_AccV as PARMCI_AccV
#endif
/* -- end weak symbols block -- */
/** Generalized I/O vector one-sided accumulate.
*
* @param[in] iov Vector of transfer information.
* @param[in] iov_len Length of iov.
* @param[in] proc Target process.
* @return Success 0, otherwise non-zero.
*/
int PARMCI_AccV(int datatype, void *scale, armci_giov_t *iov, int iov_len, int proc) {
int v;
for (v = 0; v < iov_len; v++) {
void **src_buf;
int overlapping, same_alloc;
if (iov[v].ptr_array_len == 0) continue; // NOP //
if (iov[v].bytes == 0) continue; // NOP //
overlapping = ARMCII_Iov_check_overlap(iov[v].dst_ptr_array, iov[v].ptr_array_len, iov[v].bytes);
same_alloc = ARMCII_Iov_check_same_allocation(iov[v].dst_ptr_array, iov[v].ptr_array_len, proc);
ARMCII_Buf_prepare_acc_vec(iov[v].src_ptr_array, &src_buf, iov[v].ptr_array_len, iov[v].bytes, datatype, scale);
ARMCII_Iov_op_dispatch(ARMCII_OP_ACC, src_buf, iov[v].dst_ptr_array, iov[v].ptr_array_len, iov[v].bytes, datatype,
overlapping, same_alloc, proc, 1 /* blocking */);
ARMCII_Buf_finish_acc_vec(iov[v].src_ptr_array, src_buf, iov[v].ptr_array_len, iov[v].bytes);
}
return 0;
}
armci-mpi/src/armci.h 0000644 0001750 0001750 00000026604 12663426407 014261 0 ustar mbanck mbanck /*
* Copyright (C) 2010. See COPYRIGHT in top-level directory.
*/
#ifndef _ARMCI_H_
#define _ARMCI_H_
#include
#define ARMCI_MPI 3
enum ARMCI_Acc_e { ARMCI_ACC_INT /* int */, ARMCI_ACC_LNG /* long */,
ARMCI_ACC_FLT /* float */, ARMCI_ACC_DBL /* double */,
ARMCI_ACC_CPL /* complex */, ARMCI_ACC_DCP /* double complex */ };
typedef long armci_size_t;
int ARMCI_Init(void);
int ARMCI_Init_args(int *argc, char ***argv);
int ARMCI_Initialized(void);
int ARMCI_Finalize(void);
void ARMCI_Cleanup(void);
void ARMCI_Error(const char *msg, int code);
int ARMCI_Malloc(void **base_ptrs, armci_size_t size);
int ARMCI_Free(void *ptr);
void *ARMCI_Malloc_local(armci_size_t size);
int ARMCI_Free_local(void *ptr);
void ARMCI_Barrier(void);
void ARMCI_Fence(int proc);
void ARMCI_AllFence(void);
void ARMCI_Access_begin(void *ptr); /* NEW API */
void ARMCI_Access_end(void *ptr); /* NEW API */
void ARMCI_Copy(const void *src, void *dst, int size);
int ARMCI_Get(void *src, void *dst, int size, int target);
int ARMCI_Put(void *src, void *dst, int size, int target);
int ARMCI_Acc(int datatype, void *scale, void *src, void *dst, int bytes, int proc);
int ARMCI_PutS(void *src_ptr, int src_stride_ar[/*stride_levels*/],
void *dst_ptr, int dst_stride_ar[/*stride_levels*/],
int count[/*stride_levels+1*/], int stride_levels, int proc);
int ARMCI_GetS(void *src_ptr, int src_stride_ar[/*stride_levels*/],
void *dst_ptr, int dst_stride_ar[/*stride_levels*/],
int count[/*stride_levels+1*/], int stride_levels, int proc);
int ARMCI_AccS(int datatype, void *scale,
void *src_ptr, int src_stride_ar[/*stride_levels*/],
void *dst_ptr, int dst_stride_ar[/*stride_levels*/],
int count[/*stride_levels+1*/], int stride_levels, int proc);
int ARMCI_Put_flag(void *src, void* dst, int size, int *flag, int value, int proc);
int ARMCI_PutS_flag(void *src_ptr, int src_stride_ar[/*stride_levels*/],
void *dst_ptr, int dst_stride_ar[/*stride_levels*/],
int count[/*stride_levels+1*/], int stride_levels,
int *flag, int value, int proc);
typedef struct armci_hdl_s
{
int target; /* we do not actually support individual completion */
int aggregate;
}
armci_hdl_t;
void ARMCI_INIT_HANDLE(armci_hdl_t *hdl);
void ARMCI_SET_AGGREGATE_HANDLE(armci_hdl_t* handle);
void ARMCI_UNSET_AGGREGATE_HANDLE(armci_hdl_t* handle);
int ARMCI_NbPut(void *src, void *dst, int bytes, int proc, armci_hdl_t *hdl);
int ARMCI_NbGet(void *src, void *dst, int bytes, int proc, armci_hdl_t *hdl);
int ARMCI_NbAcc(int datatype, void *scale, void *src, void *dst, int bytes, int proc, armci_hdl_t *hdl);
int ARMCI_Wait(armci_hdl_t* hdl);
int ARMCI_Test(armci_hdl_t* hdl);
int ARMCI_WaitProc(int proc);
int ARMCI_WaitAll(void);
int ARMCI_NbPutS(void *src_ptr, int src_stride_ar[/*stride_levels*/],
void *dst_ptr, int dst_stride_ar[/*stride_levels*/],
int count[/*stride_levels+1*/], int stride_levels, int proc, armci_hdl_t *hdl);
int ARMCI_NbGetS(void *src_ptr, int src_stride_ar[/*stride_levels*/],
void *dst_ptr, int dst_stride_ar[/*stride_levels*/],
int count[/*stride_levels+1*/], int stride_levels, int proc, armci_hdl_t *hdl);
int ARMCI_NbAccS(int datatype, void *scale,
void *src_ptr, int src_stride_ar[/*stride_levels*/],
void *dst_ptr, int dst_stride_ar[/*stride_levels*/],
int count[/*stride_levels+1*/], int stride_levels, int proc, armci_hdl_t *hdl);
void armci_write_strided(void *ptr, int stride_levels, int stride_arr[], int count[], char *buf);
void armci_read_strided(void *ptr, int stride_levels, int stride_arr[], int count[], char *buf);
/** Generalized I/O Vector operations.
*/
typedef struct {
void **src_ptr_array; // Source starting addresses of each data segment.
void **dst_ptr_array; // Destination starting addresses of each data segment.
int bytes; // The length of each segment in bytes.
int ptr_array_len; // Number of data segment.
} armci_giov_t;
int ARMCI_PutV(armci_giov_t *iov, int iov_len, int proc);
int ARMCI_GetV(armci_giov_t *iov, int iov_len, int proc);
int ARMCI_AccV(int datatype, void *scale, armci_giov_t *iov, int iov_len, int proc);
int ARMCI_NbPutV(armci_giov_t *iov, int iov_len, int proc, armci_hdl_t* handle);
int ARMCI_NbGetV(armci_giov_t *iov, int iov_len, int proc, armci_hdl_t* handle);
int ARMCI_NbAccV(int datatype, void *scale, armci_giov_t *iov, int iov_len, int proc, armci_hdl_t* handle);
/** Scalar/value operations.
*/
int ARMCI_PutValueInt(int src, void *dst, int proc);
int ARMCI_PutValueLong(long src, void *dst, int proc);
int ARMCI_PutValueFloat(float src, void *dst, int proc);
int ARMCI_PutValueDouble(double src, void *dst, int proc);
int ARMCI_NbPutValueInt(int src, void *dst, int proc, armci_hdl_t *hdl);
int ARMCI_NbPutValueLong(long src, void *dst, int proc, armci_hdl_t *hdl);
int ARMCI_NbPutValueFloat(float src, void *dst, int proc, armci_hdl_t *hdl);
int ARMCI_NbPutValueDouble(double src, void *dst, int proc, armci_hdl_t *hdl);
int ARMCI_GetValueInt(void *src, int proc);
long ARMCI_GetValueLong(void *src, int proc);
float ARMCI_GetValueFloat(void *src, int proc);
double ARMCI_GetValueDouble(void *src, int proc);
/** Mutexes
*/
int ARMCI_Create_mutexes(int count);
int ARMCI_Destroy_mutexes(void);
void ARMCI_Lock(int mutex, int proc);
void ARMCI_Unlock(int mutex, int proc);
/** ARMCI Read-Modify-Write API
*/
enum ARMCI_Rmw_e { ARMCI_FETCH_AND_ADD, ARMCI_FETCH_AND_ADD_LONG,
ARMCI_SWAP, ARMCI_SWAP_LONG };
int ARMCI_Rmw(int op, void *ploc, void *prem, int value, int proc);
/** ARMCI Groups API
*/
typedef struct {
MPI_Comm comm;
MPI_Comm noncoll_pgroup_comm;
int *grp_to_abs;
int *abs_to_grp;
int rank;
int size;
} ARMCI_Group;
void ARMCI_Group_create(int grp_size, int *pid_list, ARMCI_Group *group_out);
void ARMCI_Group_create_child(int grp_size, int *pid_list, ARMCI_Group *group_out, ARMCI_Group *group_parent);
void ARMCI_Group_free(ARMCI_Group *group);
int ARMCI_Group_rank(ARMCI_Group *group, int *rank);
void ARMCI_Group_size(ARMCI_Group *group, int *size);
void ARMCI_Group_set_default(ARMCI_Group *group);
void ARMCI_Group_get_default(ARMCI_Group *group_out);
void ARMCI_Group_get_world(ARMCI_Group *group_out);
int ARMCI_Absolute_id(ARMCI_Group *group,int group_rank);
int ARMCI_Malloc_group(void **ptr_arr, armci_size_t bytes, ARMCI_Group *group);
int ARMCI_Free_group(void *ptr, ARMCI_Group *group);
/** ARMCI Message API is in another file:
*/
#include
/** Topology API
*/
enum armci_domain_e { ARMCI_DOMAIN_SMP };
typedef int armci_domain_t;
int armci_domain_nprocs(armci_domain_t domain, int id);
int armci_domain_id(armci_domain_t domain, int glob_proc_id);
int armci_domain_glob_proc_id(armci_domain_t domain, int id, int loc_proc_id);
int armci_domain_my_id(armci_domain_t domain);
int armci_domain_count(armci_domain_t domain);
int armci_domain_same_id(armci_domain_t domain, int proc);
int ARMCI_Same_node(int proc);
/** Odds and ends
*/
int ARMCI_Uses_shm(void);
void ARMCI_Set_shm_limit(unsigned long shmemlimit);
int ARMCI_Uses_shm_grp(ARMCI_Group *group);
/** PARMCI -- Profiling Interface
*/
int PARMCI_Init(void);
int PARMCI_Init_args(int *argc, char ***argv);
int PARMCI_Initialized(void);
int PARMCI_Finalize(void);
int PARMCI_Malloc(void **base_ptrs, armci_size_t size);
int PARMCI_Free(void *ptr);
void *PARMCI_Malloc_local(armci_size_t size);
int PARMCI_Free_local(void *ptr);
void PARMCI_Barrier(void);
void PARMCI_Fence(int proc);
void PARMCI_AllFence(void);
void PARMCI_Access_begin(void *ptr);
void PARMCI_Access_end(void *ptr);
int PARMCI_Get(void *src, void *dst, int size, int target);
int PARMCI_Put(void *src, void *dst, int size, int target);
int PARMCI_Acc(int datatype, void *scale, void *src, void *dst, int bytes, int proc);
int PARMCI_PutS(void *src_ptr, int src_stride_ar[], void *dst_ptr, int dst_stride_ar[],
int count[], int stride_levels, int proc);
int PARMCI_GetS(void *src_ptr, int src_stride_ar[], void *dst_ptr, int dst_stride_ar[],
int count[], int stride_levels, int proc);
int PARMCI_AccS(int datatype, void *scale, void *src_ptr, int src_stride_ar[],
void *dst_ptr, int dst_stride_ar[], int count[], int stride_levels, int proc);
int PARMCI_Put_flag(void *src, void* dst, int size, int *flag, int value, int proc);
int PARMCI_PutS_flag(void *src_ptr, int src_stride_ar[], void *dst_ptr, int dst_stride_ar[],
int count[], int stride_levels, int *flag, int value, int proc);
int PARMCI_PutV(armci_giov_t *iov, int iov_len, int proc);
int PARMCI_GetV(armci_giov_t *iov, int iov_len, int proc);
int PARMCI_AccV(int datatype, void *scale, armci_giov_t *iov, int iov_len, int proc);
int PARMCI_Wait(armci_hdl_t* hdl);
int PARMCI_Test(armci_hdl_t* hdl);
int PARMCI_WaitProc(int proc);
int PARMCI_WaitAll(void);
int PARMCI_NbPut(void *src, void *dst, int bytes, int proc, armci_hdl_t *hdl);
int PARMCI_NbGet(void *src, void *dst, int bytes, int proc, armci_hdl_t *hdl);
int PARMCI_NbAcc(int datatype, void *scale, void *src, void *dst, int bytes, int proc, armci_hdl_t *hdl);
int PARMCI_NbPutS(void *src_ptr, int src_stride_ar[], void *dst_ptr, int dst_stride_ar[],
int count[], int stride_levels, int proc, armci_hdl_t *hdl);
int PARMCI_NbGetS(void *src_ptr, int src_stride_ar[], void *dst_ptr, int dst_stride_ar[],
int count[], int stride_levels, int proc, armci_hdl_t *hdl);
int PARMCI_NbAccS(int datatype, void *scale, void *src_ptr, int src_stride_ar[],
void *dst_ptr, int dst_stride_ar[], int count[], int stride_levels, int proc, armci_hdl_t *hdl);
int PARMCI_NbPutV(armci_giov_t *iov, int iov_len, int proc, armci_hdl_t* handle);
int PARMCI_NbGetV(armci_giov_t *iov, int iov_len, int proc, armci_hdl_t* handle);
int PARMCI_NbAccV(int datatype, void *scale, armci_giov_t *iov, int iov_len, int proc, armci_hdl_t* handle);
int PARMCI_PutValueInt(int src, void *dst, int proc);
int PARMCI_PutValueLong(long src, void *dst, int proc);
int PARMCI_PutValueFloat(float src, void *dst, int proc);
int PARMCI_PutValueDouble(double src, void *dst, int proc);
int PARMCI_NbPutValueInt(int src, void *dst, int proc, armci_hdl_t *hdl);
int PARMCI_NbPutValueLong(long src, void *dst, int proc, armci_hdl_t *hdl);
int PARMCI_NbPutValueFloat(float src, void *dst, int proc, armci_hdl_t *hdl);
int PARMCI_NbPutValueDouble(double src, void *dst, int proc, armci_hdl_t *hdl);
int PARMCI_GetValueInt(void *src, int proc);
long PARMCI_GetValueLong(void *src, int proc);
float PARMCI_GetValueFloat(void *src, int proc);
double PARMCI_GetValueDouble(void *src, int proc);
int PARMCI_Create_mutexes(int count);
int PARMCI_Destroy_mutexes(void);
void PARMCI_Lock(int mutex, int proc);
void PARMCI_Unlock(int mutex, int proc);
int PARMCI_Rmw(int op, void *ploc, void *prem, int value, int proc);
void parmci_msg_barrier(void);
void parmci_msg_group_barrier(ARMCI_Group *group);
#endif /* _ARMCI_H_ */
armci-mpi/src/onesided_nb.c 0000644 0001750 0001750 00000020127 12663426407 015424 0 ustar mbanck mbanck /*
* Copyright (C) 2010. See COPYRIGHT in top-level directory.
*/
#include
#include
#include
#include
#include
/** Initialize Non-blocking handle.
*/
void ARMCI_INIT_HANDLE(armci_hdl_t *handle) {
if (handle!=NULL) {
handle->aggregate = 1;
handle->target = -1;
} else {
ARMCII_Warning("ARMCI_INIT_HANDLE given NULL handle");
}
return;
}
/** Mark a handle as aggregate.
*/
void ARMCI_SET_AGGREGATE_HANDLE(armci_hdl_t *handle) {
if (handle!=NULL) {
handle->aggregate = 1;
} else {
ARMCII_Warning("ARMCI_INIT_HANDLE given NULL handle");
}
return;
}
/** Clear an aggregate handle.
*/
void ARMCI_UNSET_AGGREGATE_HANDLE(armci_hdl_t *handle) {
if (handle!=NULL) {
handle->aggregate = 0;
} else {
ARMCII_Warning("ARMCI_INIT_HANDLE given NULL handle");
}
return;
}
/* -- begin weak symbols block -- */
#if defined(HAVE_PRAGMA_WEAK)
# pragma weak ARMCI_NbPut = PARMCI_NbPut
#elif defined(HAVE_PRAGMA_HP_SEC_DEF)
# pragma _HP_SECONDARY_DEF PARMCI_NbPut ARMCI_NbPut
#elif defined(HAVE_PRAGMA_CRI_DUP)
# pragma _CRI duplicate ARMCI_NbPut as PARMCI_NbPut
#endif
/* -- end weak symbols block -- */
/** Non-blocking put operation.
*/
int PARMCI_NbPut(void *src, void *dst, int size, int target, armci_hdl_t *handle) {
gmr_t *src_mreg, *dst_mreg;
dst_mreg = gmr_lookup(dst, target);
/* If NOGUARD is set, assume the buffer is not shared */
if (ARMCII_GLOBAL_STATE.shr_buf_method != ARMCII_SHR_BUF_NOGUARD)
src_mreg = gmr_lookup(src, ARMCI_GROUP_WORLD.rank);
else
src_mreg = NULL;
ARMCII_Assert_msg(dst_mreg != NULL, "Invalid remote pointer");
/* Local operation */
if (target == ARMCI_GROUP_WORLD.rank && src_mreg == NULL) {
ARMCI_Copy(src, dst, size);
}
else {
gmr_put(dst_mreg, src, dst, size, target);
}
if (handle!=NULL) {
/* Regular (not aggregate) handles merely store the target for future flushing. */
handle->target = target;
}
#ifdef EXPLICIT_PROGRESS
gmr_progress();
#endif
return 0;
}
/* -- begin weak symbols block -- */
#if defined(HAVE_PRAGMA_WEAK)
# pragma weak ARMCI_NbGet = PARMCI_NbGet
#elif defined(HAVE_PRAGMA_HP_SEC_DEF)
# pragma _HP_SECONDARY_DEF PARMCI_NbGet ARMCI_NbGet
#elif defined(HAVE_PRAGMA_CRI_DUP)
# pragma _CRI duplicate ARMCI_NbGet as PARMCI_NbGet
#endif
/* -- end weak symbols block -- */
/** Non-blocking get operation. Note: the implementation is not non-blocking
*/
int PARMCI_NbGet(void *src, void *dst, int size, int target, armci_hdl_t *handle) {
gmr_t *src_mreg, *dst_mreg;
src_mreg = gmr_lookup(src, target);
/* If NOGUARD is set, assume the buffer is not shared */
if (ARMCII_GLOBAL_STATE.shr_buf_method != ARMCII_SHR_BUF_NOGUARD)
dst_mreg = gmr_lookup(dst, ARMCI_GROUP_WORLD.rank);
else
dst_mreg = NULL;
ARMCII_Assert_msg(src_mreg != NULL, "Invalid remote pointer");
/* Local operation */
if (target == ARMCI_GROUP_WORLD.rank && dst_mreg == NULL) {
ARMCI_Copy(src, dst, size);
}
else {
gmr_get(src_mreg, src, dst, size, target);
}
if (handle!=NULL) {
/* Regular (not aggregate) handles merely store the target for future flushing. */
handle->target = target;
}
#ifdef EXPLICIT_PROGRESS
gmr_progress();
#endif
return 0;
}
/* -- begin weak symbols block -- */
#if defined(HAVE_PRAGMA_WEAK)
# pragma weak ARMCI_NbAcc = PARMCI_NbAcc
#elif defined(HAVE_PRAGMA_HP_SEC_DEF)
# pragma _HP_SECONDARY_DEF PARMCI_NbAcc ARMCI_NbAcc
#elif defined(HAVE_PRAGMA_CRI_DUP)
# pragma _CRI duplicate ARMCI_NbAcc as PARMCI_NbAcc
#endif
/* -- end weak symbols block -- */
/** Non-blocking accumulate operation. Note: the implementation is not non-blocking
*/
int PARMCI_NbAcc(int datatype, void *scale, void *src, void *dst, int bytes, int target, armci_hdl_t *handle) {
void *src_buf;
int count, type_size, scaled;
MPI_Datatype type;
gmr_t *src_mreg, *dst_mreg;
/* If NOGUARD is set, assume the buffer is not shared */
if (ARMCII_GLOBAL_STATE.shr_buf_method != ARMCII_SHR_BUF_NOGUARD)
src_mreg = gmr_lookup(src, ARMCI_GROUP_WORLD.rank);
else
src_mreg = NULL;
dst_mreg = gmr_lookup(dst, target);
ARMCII_Assert_msg(dst_mreg != NULL, "Invalid remote pointer");
/* Prepare the input data: Apply scaling if needed and acquire the DLA lock if
* needed. We hold the DLA lock if (src_buf == src && src_mreg != NULL). */
scaled = ARMCII_Buf_acc_is_scaled(datatype, scale);
if (scaled) {
MPI_Alloc_mem(bytes, MPI_INFO_NULL, &src_buf);
ARMCII_Assert(src_buf != NULL);
ARMCII_Buf_acc_scale(src, src_buf, bytes, datatype, scale);
} else {
src_buf = src;
}
/* Check if we need to copy: user requested it or same mem region */
if ( (src_buf == src) /* buf_prepare didn't make a copy */
&& (ARMCII_GLOBAL_STATE.shr_buf_method == ARMCII_SHR_BUF_COPY || src_mreg == dst_mreg) )
{
MPI_Alloc_mem(bytes, MPI_INFO_NULL, &src_buf);
ARMCII_Assert(src_buf != NULL);
ARMCI_Copy(src, src_buf, bytes);
}
ARMCII_Acc_type_translate(datatype, &type, &type_size);
count = bytes/type_size;
ARMCII_Assert_msg(bytes % type_size == 0,
"Transfer size is not a multiple of the datatype size");
/* TODO: Support a local accumulate operation more efficiently */
gmr_accumulate(dst_mreg, src_buf, dst, count, type, target);
if (src_buf != src) {
/* must wait for local completion to free source buffer */
gmr_flush(dst_mreg, target, 1); /* flush local only, unlike Fence */
MPI_Free_mem(src_buf);
}
if (handle!=NULL) {
/* Regular (not aggregate) handles merely store the target for future flushing. */
handle->target = target;
}
#ifdef EXPLICIT_PROGRESS
gmr_progress();
#endif
return 0;
}
/* -- begin weak symbols block -- */
#if defined(HAVE_PRAGMA_WEAK)
# pragma weak ARMCI_Wait = PARMCI_Wait
#elif defined(HAVE_PRAGMA_HP_SEC_DEF)
# pragma _HP_SECONDARY_DEF PARMCI_Wait ARMCI_Wait
#elif defined(HAVE_PRAGMA_CRI_DUP)
# pragma _CRI duplicate ARMCI_Wait as PARMCI_Wait
#endif
/* -- end weak symbols block -- */
/** Wait for a non-blocking operation to finish.
*/
int PARMCI_Wait(armci_hdl_t* handle) {
gmr_t *cur_mreg = gmr_list;
if(handle->aggregate > 0) {
while (cur_mreg) {
gmr_flushall(cur_mreg, 1); /* local only */
cur_mreg = cur_mreg->next;
}
}
else {
int proc = handle->target;
while (cur_mreg) {
gmr_flush(cur_mreg, proc, 1); /* local only */
cur_mreg = cur_mreg->next;
}
}
return 0;
}
/* -- begin weak symbols block -- */
#if defined(HAVE_PRAGMA_WEAK)
# pragma weak ARMCI_Test = PARMCI_Test
#elif defined(HAVE_PRAGMA_HP_SEC_DEF)
# pragma _HP_SECONDARY_DEF PARMCI_Test ARMCI_Test
#elif defined(HAVE_PRAGMA_CRI_DUP)
# pragma _CRI duplicate ARMCI_Test as PARMCI_Test
#endif
/* -- end weak symbols block -- */
/** Check if a non-blocking operation has finished.
*/
int PARMCI_Test(armci_hdl_t* handle) {
return PARMCI_Wait(handle);
}
/* -- begin weak symbols block -- */
#if defined(HAVE_PRAGMA_WEAK)
# pragma weak ARMCI_WaitProc = PARMCI_WaitProc
#elif defined(HAVE_PRAGMA_HP_SEC_DEF)
# pragma _HP_SECONDARY_DEF PARMCI_WaitProc ARMCI_WaitProc
#elif defined(HAVE_PRAGMA_CRI_DUP)
# pragma _CRI duplicate ARMCI_WaitProc as PARMCI_WaitProc
#endif
/* -- end weak symbols block -- */
/** Wait for all outstanding non-blocking operations with implicit handles to a particular process to finish.
*/
int PARMCI_WaitProc(int proc) {
gmr_t *cur_mreg = gmr_list;
while (cur_mreg) {
gmr_flush(cur_mreg, proc, 1); /* local only */
cur_mreg = cur_mreg->next;
}
return 0;
}
/* -- begin weak symbols block -- */
#if defined(HAVE_PRAGMA_WEAK)
# pragma weak ARMCI_WaitAll = PARMCI_WaitAll
#elif defined(HAVE_PRAGMA_HP_SEC_DEF)
# pragma _HP_SECONDARY_DEF PARMCI_WaitAll ARMCI_WaitAll
#elif defined(HAVE_PRAGMA_CRI_DUP)
# pragma _CRI duplicate ARMCI_WaitAll as PARMCI_WaitAll
#endif
/* -- end weak symbols block -- */
/** Wait for all non-blocking operations with implicit (NULL) handles to finish.
*/
int PARMCI_WaitAll(void) {
gmr_t *cur_mreg = gmr_list;
while (cur_mreg) {
gmr_flushall(cur_mreg, 1); /* local only */
cur_mreg = cur_mreg->next;
}
return 0;
}
armci-mpi/src/onesided.c 0000644 0001750 0001750 00000022065 12663426407 014750 0 ustar mbanck mbanck /*
* Copyright (C) 2010. See COPYRIGHT in top-level directory.
*/
#include
#include
#include
#include
#include
#include
#include
#include
/* -- begin weak symbols block -- */
#if defined(HAVE_PRAGMA_WEAK)
# pragma weak ARMCI_Access_begin = PARMCI_Access_begin
#elif defined(HAVE_PRAGMA_HP_SEC_DEF)
# pragma _HP_SECONDARY_DEF PARMCI_Access_begin ARMCI_Access_begin
#elif defined(HAVE_PRAGMA_CRI_DUP)
# pragma _CRI duplicate ARMCI_Access_begin as PARMCI_Access_begin
#endif
/* -- end weak symbols block -- */
/** Declare the start of a local access epoch. This allows direct access to
* data in local memory.
*
* @param[in] ptr Pointer to the allocation that will be accessed directly
*/
void PARMCI_Access_begin(void *ptr) {
gmr_t *mreg;
mreg = gmr_lookup(ptr, ARMCI_GROUP_WORLD.rank);
ARMCII_Assert_msg(mreg != NULL, "Invalid remote pointer");
gmr_sync(mreg);
}
/* -- begin weak symbols block -- */
#if defined(HAVE_PRAGMA_WEAK)
# pragma weak ARMCI_Access_end = PARMCI_Access_end
#elif defined(HAVE_PRAGMA_HP_SEC_DEF)
# pragma _HP_SECONDARY_DEF PARMCI_Access_end ARMCI_Access_end
#elif defined(HAVE_PRAGMA_CRI_DUP)
# pragma _CRI duplicate ARMCI_Access_end as PARMCI_Access_end
#endif
/* -- end weak symbols block -- */
/** Declare the end of a local access epoch.
*
* \note MPI-2 does not allow multiple locks at once, so you can have only one
* access epoch open at a time and cannot do put/get/acc while in an access
* region.
*
* @param[in] ptr Pointer to the allocation that was accessed directly
*/
void PARMCI_Access_end(void *ptr) {
gmr_t *mreg;
mreg = gmr_lookup(ptr, ARMCI_GROUP_WORLD.rank);
ARMCII_Assert_msg(mreg != NULL, "Invalid remote pointer");
gmr_sync(mreg);
}
/* -- begin weak symbols block -- */
#if defined(HAVE_PRAGMA_WEAK)
# pragma weak ARMCI_Get = PARMCI_Get
#elif defined(HAVE_PRAGMA_HP_SEC_DEF)
# pragma _HP_SECONDARY_DEF PARMCI_Get ARMCI_Get
#elif defined(HAVE_PRAGMA_CRI_DUP)
# pragma _CRI duplicate ARMCI_Get as PARMCI_Get
#endif
/* -- end weak symbols block -- */
/** One-sided get operation.
*
* @param[in] src Source address (remote)
* @param[in] dst Destination address (local)
* @param[in] size Number of bytes to transfer
* @param[in] target Process id to target
* @return 0 on success, non-zero on failure
*/
int PARMCI_Get(void *src, void *dst, int size, int target) {
gmr_t *src_mreg, *dst_mreg;
src_mreg = gmr_lookup(src, target);
/* If NOGUARD is set, assume the buffer is not shared */
if (ARMCII_GLOBAL_STATE.shr_buf_method != ARMCII_SHR_BUF_NOGUARD)
dst_mreg = gmr_lookup(dst, ARMCI_GROUP_WORLD.rank);
else
dst_mreg = NULL;
ARMCII_Assert_msg(src_mreg != NULL, "Invalid remote pointer");
/* Local operation */
if (target == ARMCI_GROUP_WORLD.rank && dst_mreg == NULL) {
ARMCI_Copy(src, dst, size);
}
/* Origin buffer is private */
else if (dst_mreg == NULL) {
gmr_get(src_mreg, src, dst, size, target);
gmr_flush(src_mreg, target, 0); /* it's a round trip so w.r.t. flush, local=remote */
}
/* COPY: Either origin and target buffers are in the same window and we can't
* lock the same window twice (MPI semantics) or the user has requested
* always-copy mode. */
else {
void *dst_buf;
MPI_Alloc_mem(size, MPI_INFO_NULL, &dst_buf);
ARMCII_Assert(dst_buf != NULL);
gmr_get(src_mreg, src, dst_buf, size, target);
gmr_flush(src_mreg, target, 0); /* it's a round trip so w.r.t. flush, local=remote */
ARMCI_Copy(dst_buf, dst, size);
MPI_Free_mem(dst_buf);
}
return 0;
}
/* -- begin weak symbols block -- */
#if defined(HAVE_PRAGMA_WEAK)
# pragma weak ARMCI_Put = PARMCI_Put
#elif defined(HAVE_PRAGMA_HP_SEC_DEF)
# pragma _HP_SECONDARY_DEF PARMCI_Put ARMCI_Put
#elif defined(HAVE_PRAGMA_CRI_DUP)
# pragma _CRI duplicate ARMCI_Put as PARMCI_Put
#endif
/* -- end weak symbols block -- */
/** One-sided put operation.
*
* @param[in] src Source address (remote)
* @param[in] dst Destination address (local)
* @param[in] size Number of bytes to transfer
* @param[in] target Process id to target
* @return 0 on success, non-zero on failure
*/
int PARMCI_Put(void *src, void *dst, int size, int target) {
gmr_t *src_mreg, *dst_mreg;
dst_mreg = gmr_lookup(dst, target);
/* If NOGUARD is set, assume the buffer is not shared */
if (ARMCII_GLOBAL_STATE.shr_buf_method != ARMCII_SHR_BUF_NOGUARD)
src_mreg = gmr_lookup(src, ARMCI_GROUP_WORLD.rank);
else
src_mreg = NULL;
ARMCII_Assert_msg(dst_mreg != NULL, "Invalid remote pointer");
/* Local operation */
if (target == ARMCI_GROUP_WORLD.rank && src_mreg == NULL) {
ARMCI_Copy(src, dst, size);
}
/* Origin buffer is private */
else if (src_mreg == NULL) {
gmr_put(dst_mreg, src, dst, size, target);
gmr_flush(dst_mreg, target, 1); /* flush_local */
}
/* COPY: Either origin and target buffers are in the same window and we can't
* lock the same window twice (MPI semantics) or the user has requested
* always-copy mode. */
else {
void *src_buf;
MPI_Alloc_mem(size, MPI_INFO_NULL, &src_buf);
ARMCII_Assert(src_buf != NULL);
ARMCI_Copy(src, src_buf, size);
gmr_put(dst_mreg, src_buf, dst, size, target);
gmr_flush(dst_mreg, target, 1); /* flush_local */
MPI_Free_mem(src_buf);
}
return 0;
}
/* -- begin weak symbols block -- */
#if defined(HAVE_PRAGMA_WEAK)
# pragma weak ARMCI_Acc = PARMCI_Acc
#elif defined(HAVE_PRAGMA_HP_SEC_DEF)
# pragma _HP_SECONDARY_DEF PARMCI_Acc ARMCI_Acc
#elif defined(HAVE_PRAGMA_CRI_DUP)
# pragma _CRI duplicate ARMCI_Acc as PARMCI_Acc
#endif
/* -- end weak symbols block -- */
/** One-sided accumulate operation.
*
* @param[in] datatype ARMCI data type for the accumulate operation (see armci.h)
* @param[in] scale Pointer for a scalar of type datatype that will be used to
* scale values in the source buffer
* @param[in] src Source address (remote)
* @param[in] dst Destination address (local)
* @param[in] bytes Number of bytes to transfer
* @param[in] proc Process id to target
* @return 0 on success, non-zero on failure
*/
int PARMCI_Acc(int datatype, void *scale, void *src, void *dst, int bytes, int proc) {
void *src_buf;
int count, type_size, scaled;
MPI_Datatype type;
gmr_t *src_mreg, *dst_mreg;
/* If NOGUARD is set, assume the buffer is not shared */
if (ARMCII_GLOBAL_STATE.shr_buf_method != ARMCII_SHR_BUF_NOGUARD)
src_mreg = gmr_lookup(src, ARMCI_GROUP_WORLD.rank);
else
src_mreg = NULL;
dst_mreg = gmr_lookup(dst, proc);
ARMCII_Assert_msg(dst_mreg != NULL, "Invalid remote pointer");
/* Prepare the input data: Apply scaling if needed and acquire the DLA lock if
* needed. We hold the DLA lock if (src_buf == src && src_mreg != NULL). */
scaled = ARMCII_Buf_acc_is_scaled(datatype, scale);
if (scaled) {
MPI_Alloc_mem(bytes, MPI_INFO_NULL, &src_buf);
ARMCII_Assert(src_buf != NULL);
ARMCII_Buf_acc_scale(src, src_buf, bytes, datatype, scale);
} else {
src_buf = src;
}
/* Check if we need to copy: user requested it or same mem region */
if ( (src_buf == src) /* buf_prepare didn't make a copy */
&& (ARMCII_GLOBAL_STATE.shr_buf_method == ARMCII_SHR_BUF_COPY || src_mreg == dst_mreg) )
{
MPI_Alloc_mem(bytes, MPI_INFO_NULL, &src_buf);
ARMCII_Assert(src_buf != NULL);
ARMCI_Copy(src, src_buf, bytes);
}
ARMCII_Acc_type_translate(datatype, &type, &type_size);
count = bytes/type_size;
ARMCII_Assert_msg(bytes % type_size == 0,
"Transfer size is not a multiple of the datatype size");
/* TODO: Support a local accumulate operation more efficiently */
gmr_accumulate(dst_mreg, src_buf, dst, count, type, proc);
gmr_flush(dst_mreg, proc, 1); /* flush_local */
if (src_buf != src)
MPI_Free_mem(src_buf);
return 0;
}
/* -- begin weak symbols block -- */
#if defined(HAVE_PRAGMA_WEAK)
# pragma weak ARMCI_Put_flag = PARMCI_Put_flag
#elif defined(HAVE_PRAGMA_HP_SEC_DEF)
# pragma _HP_SECONDARY_DEF PARMCI_Put_flag ARMCI_Put_flag
#elif defined(HAVE_PRAGMA_CRI_DUP)
# pragma _CRI duplicate ARMCI_Put_flag as PARMCI_Put_flag
#endif
/* -- end weak symbols block -- */
/** One-sided copy of data from the source to the destination. Set a flag on
* the remote process when the transfer is complete.
*
* @param[in] src Source buffer
* @param[in] dst Destination buffer on proc
* @param[in] size Number of bytes to transfer
* @param[in] flag Address of the flag buffer on proc
* @param[in] value Value to set the flag to
* @param[in] proc Process id of the target
* @return 0 on success, non-zero on failure
*/
int PARMCI_Put_flag(void *src, void* dst, int size, int *flag, int value, int proc) {
/* TODO: This can be optimized with a more direct implementation, especially in the
* case where RMA is ordered; in that case, the Fence (Flush) is not necessary. */
PARMCI_Put(src, dst, size, proc);
PARMCI_Fence(proc);
PARMCI_Put(&value, flag, sizeof(int), proc);
return 0;
}
armci-mpi/src/mp3.h 0000644 0001750 0001750 00000000743 12662706250 013655 0 ustar mbanck mbanck #ifndef _MP3_H_
#define _MP3_H_
#include
#define MP_INIT(ARGC,ARGV) MPI_Init(&(ARGC),&(ARGV))
#define MP_BARRIER() MPI_Barrier(MPI_COMM_WORLD)
#define MP_FINALIZE() MPI_Finalize()
#define MP_PROCS(X) MPI_Comm_size(MPI_COMM_WORLD,X)
#define MP_MYID(X) MPI_Comm_rank(MPI_COMM_WORLD,X)
#define MP_TIMER() MPI_Wtime()
#define GA_INIT(ARGC,ARGV) GA_Initialize()
#define ARMCI_INIT(ARGC,ARGV) ARMCI_Init()
#endif /* _MP3_H_ */
armci-mpi/src/groups.c 0000644 0001750 0001750 00000025152 12662706250 014471 0 ustar mbanck mbanck /*
* Copyright (C) 2010. See COPYRIGHT in top-level directory.
*/
#include
#include
#include
#include
#include
#include
/** The ARMCI world group. This is accessed from outside via
* ARMCI_Group_get_world.
*/
ARMCI_Group ARMCI_GROUP_WORLD = {0};
ARMCI_Group ARMCI_GROUP_DEFAULT = {0};
/** Initialize an ARMCI group's remaining fields using the communicator field.
*/
void ARMCII_Group_init_from_comm(ARMCI_Group *group) {
if (group->comm != MPI_COMM_NULL) {
MPI_Comm_size(group->comm, &group->size);
MPI_Comm_rank(group->comm, &group->rank);
} else {
group->rank = -1;
group->size = 0;
}
/* If noncollective groups are in use, create a separate communicator that
can be used for noncollective group creation with this group as the parent.
This ensures that calls to MPI_Intercomm_create can't clash with any user
communication. */
if (ARMCII_GLOBAL_STATE.noncollective_groups && group->comm != MPI_COMM_NULL)
MPI_Comm_dup(group->comm, &group->noncoll_pgroup_comm);
else
group->noncoll_pgroup_comm = MPI_COMM_NULL;
/* Check if translation caching is enabled */
if (ARMCII_GLOBAL_STATE.cache_rank_translation) {
if (group->comm != MPI_COMM_NULL) {
int *ranks, i;
MPI_Group world_group, sub_group;
group->abs_to_grp = malloc(sizeof(int)*ARMCI_GROUP_WORLD.size);
group->grp_to_abs = malloc(sizeof(int)*group->size);
ranks = malloc(sizeof(int)*ARMCI_GROUP_WORLD.size);
ARMCII_Assert(group->abs_to_grp != NULL && group->grp_to_abs != NULL && ranks != NULL);
for (i = 0; i < ARMCI_GROUP_WORLD.size; i++)
ranks[i] = i;
MPI_Comm_group(ARMCI_GROUP_WORLD.comm, &world_group);
MPI_Comm_group(group->comm, &sub_group);
MPI_Group_translate_ranks(sub_group, group->size, ranks, world_group, group->grp_to_abs);
MPI_Group_translate_ranks(world_group, ARMCI_GROUP_WORLD.size, ranks, sub_group, group->abs_to_grp);
MPI_Group_free(&world_group);
MPI_Group_free(&sub_group);
free(ranks);
}
}
/* Translation caching is disabled */
else {
group->abs_to_grp = NULL;
group->grp_to_abs = NULL;
}
}
/** Create an ARMCI group that contains a subset of the nodes in the current
* default group. Collective across the default group.
*
* @param[in] grp_size Number of entries in pid_list.
* @param[in] pid_list List of process ids that will be in the new group.
* @param[out] armci_grp_out The new ARMCI group.
* @param[in] armci_grp_parent The parent of the new ARMCI group.
*/
void ARMCI_Group_create(int grp_size, int *pid_list, ARMCI_Group *group_out) {
ARMCI_Group_create_child(grp_size, pid_list, group_out, &ARMCI_GROUP_DEFAULT);
}
/** Create an ARMCI group that contains a subset of the nodes in the parent
* group. Collective across output group.
*
* @param[in] grp_size Number of entries in pid_list.
* @param[in] pid_list List of process ids that will be in the new group.
* @param[out] armci_grp_out The new ARMCI group, only valid on group members.
* @param[in] armci_grp_parent The parent of the new ARMCI group.
*/
static inline void ARMCI_Group_create_comm_collective(int grp_size, int *pid_list, ARMCI_Group *armci_grp_out,
ARMCI_Group *armci_grp_parent) {
MPI_Group mpi_grp_parent;
MPI_Group mpi_grp_child;
MPI_Comm_group(armci_grp_parent->comm, &mpi_grp_parent);
MPI_Group_incl(mpi_grp_parent, grp_size, pid_list, &mpi_grp_child);
MPI_Comm_create(armci_grp_parent->comm, mpi_grp_child, &armci_grp_out->comm);
MPI_Group_free(&mpi_grp_parent);
MPI_Group_free(&mpi_grp_child);
}
/** Create an ARMCI group that contains a subset of the nodes in the parent
* group. Collective across output group.
*
* @param[in] grp_size Number of entries in pid_list.
* @param[in] pid_list Sorted list of process ids that will be in the new group.
* @param[out] armci_grp_out The new ARMCI group, only valid on group members.
* @param[in] armci_grp_parent The parent of the new ARMCI group.
*/
static inline void ARMCI_Group_create_comm_noncollective(int grp_size, int *pid_list, ARMCI_Group *armci_grp_out,
ARMCI_Group *armci_grp_parent) {
const int INTERCOMM_TAG = 42;
int i, grp_me, me, merge_size;
MPI_Comm pgroup, inter_pgroup;
me = armci_grp_parent->rank;
/* CHECK: If I'm not a member, return COMM_NULL */
grp_me = -1;
for (i = 0; i < grp_size; i++) {
if (pid_list[i] == me) {
grp_me = i;
break;
}
}
if (grp_me < 0) {
armci_grp_out->comm = MPI_COMM_NULL;
return;
}
/* CASE: Group size 1 */
else if (grp_size == 1 && pid_list[0] == me) {
MPI_Comm_dup(MPI_COMM_SELF, &armci_grp_out->comm);
return;
}
pgroup = MPI_COMM_SELF;
/* Recursively merge adjacent groups until only one group remains. */
for (merge_size = 1; merge_size < grp_size; merge_size *= 2) {
int gid = grp_me / merge_size;
MPI_Comm pgroup_old = pgroup;
if (gid % 2 == 0) {
/* Check if right partner doesn't exist */
if ((gid+1)*merge_size >= grp_size)
continue;
MPI_Intercomm_create(pgroup, 0, armci_grp_parent->noncoll_pgroup_comm, pid_list[(gid+1)*merge_size], INTERCOMM_TAG, &inter_pgroup);
MPI_Intercomm_merge(inter_pgroup, 0 /* LOW */, &pgroup);
} else {
MPI_Intercomm_create(pgroup, 0, armci_grp_parent->noncoll_pgroup_comm, pid_list[(gid-1)*merge_size], INTERCOMM_TAG, &inter_pgroup);
MPI_Intercomm_merge(inter_pgroup, 1 /* HIGH */, &pgroup);
}
MPI_Comm_free(&inter_pgroup);
if (pgroup_old != MPI_COMM_SELF) MPI_Comm_free(&pgroup_old);
}
armci_grp_out->comm = pgroup;
}
/** Create an ARMCI group that contains a subset of the nodes in the parent
* group. Collective.
*
* @param[in] grp_size Number of entries in pid_list.
* @param[in] pid_list Sorted list of process ids that will be in the new group.
* @param[out] armci_grp_out The new ARMCI group, only valid on group members.
* @param[in] armci_grp_parent The parent of the new ARMCI group.
*/
void ARMCI_Group_create_child(int grp_size, int *pid_list, ARMCI_Group *armci_grp_out,
ARMCI_Group *armci_grp_parent) {
if (ARMCII_GLOBAL_STATE.noncollective_groups)
ARMCI_Group_create_comm_noncollective(grp_size, pid_list, armci_grp_out, armci_grp_parent);
else
ARMCI_Group_create_comm_collective(grp_size, pid_list, armci_grp_out, armci_grp_parent);
ARMCII_Group_init_from_comm(armci_grp_out);
}
/** Free an ARMCI group. Collective across group.
*
* @param[in] group The group to be freed
*/
void ARMCI_Group_free(ARMCI_Group *group) {
if (group->comm != MPI_COMM_NULL) {
MPI_Comm_free(&group->comm);
if (ARMCII_GLOBAL_STATE.noncollective_groups)
MPI_Comm_free(&group->noncoll_pgroup_comm);
}
/* If the group has translation caches, free them */
if (group->abs_to_grp != NULL)
free(group->abs_to_grp);
if (group->grp_to_abs != NULL)
free(group->grp_to_abs);
group->rank = -1;
group->size = 0;
}
/** Query the calling process' rank in a given group.
*
* @param[in] group Group to query on.
* @param[out] rank Location to store the rank.
* @return Zero on success, error code otherwise.
*/
int ARMCI_Group_rank(ARMCI_Group *group, int *rank) {
*rank = group->rank;
if (*rank >= 0)
return 0;
else
return 1;
}
/** Query the size of the given group.
*
* @param[in] group Group to query.
* @param[out] size Variable to store the size in.
*/
void ARMCI_Group_size(ARMCI_Group *group, int *size) {
*size = group->size;
}
/** Set the default group.
*
* @param[in] group The new default group
*/
void ARMCI_Group_set_default(ARMCI_Group *group) {
ARMCI_GROUP_DEFAULT = *group;
}
/** Get the default group.
*
* @param[out] group_out Pointer to the default group.
*/
void ARMCI_Group_get_default(ARMCI_Group *group_out) {
*group_out = ARMCI_GROUP_DEFAULT;
}
/** Fetch the world group.
*
* @param[out] group_out Output group.
*/
void ARMCI_Group_get_world(ARMCI_Group *group_out) {
*group_out = ARMCI_GROUP_WORLD;
}
/** Translate a group process rank to the corresponding process rank in the
* ARMCI world group.
*
* @param[in] group Group to translate from.
* @param[in] group_rank Rank of the process in group.
*/
int ARMCI_Absolute_id(ARMCI_Group *group, int group_rank) {
int world_rank;
MPI_Group world_group, sub_group;
ARMCII_Assert(group_rank >= 0 && group_rank < group->size);
/* Check if group is the world group */
if (group->comm == ARMCI_GROUP_WORLD.comm)
world_rank = group_rank;
/* Check for translation cache */
else if (group->grp_to_abs != NULL)
world_rank = group->grp_to_abs[group_rank];
else {
/* Translate the rank */
MPI_Comm_group(ARMCI_GROUP_WORLD.comm, &world_group);
MPI_Comm_group(group->comm, &sub_group);
MPI_Group_translate_ranks(sub_group, 1, &group_rank, world_group, &world_rank);
MPI_Group_free(&world_group);
MPI_Group_free(&sub_group);
}
/* Check if translation failed */
if (world_rank == MPI_UNDEFINED)
return -1;
else
return world_rank;
}
/** Split a parent group into multiple child groups. This is similar to
* MPI_Comm_split. Collective across the parent group.
*
* @param[in] parent The parent group.
* @param[in] color The id number of the new group. Processes are grouped
* together so allthat give the same color will be placed
* in the same new group.
* @param[in] key Relative ordering of processes in the new group.
* @param[out] new_group Pointer to a handle where group info will be stored.
*/
int ARMCIX_Group_split(ARMCI_Group *parent, int color, int key, ARMCI_Group *new_group) {
int err;
err = MPI_Comm_split(parent->comm, color, key, &new_group->comm);
if (err != MPI_SUCCESS)
return err;
ARMCII_Group_init_from_comm(new_group);
return 0;
}
/** Duplicate an ARMCI group. Collective across the parent group.
*
* @param[in] parent The parent group.
* @param[in] color The id number of the new group. Processes are grouped
* together so allthat give the same color will be placed
* in the same new group.
* @param[in] key Relative ordering of processes in the new group.
* @param[out] new_group Pointer to a handle where group info will be stored.
*/
int ARMCIX_Group_dup(ARMCI_Group *parent, ARMCI_Group *new_group) {
int err;
err = MPI_Comm_dup(parent->comm, &new_group->comm);
if (err != MPI_SUCCESS)
return err;
ARMCII_Group_init_from_comm(new_group);
return 0;
}
armci-mpi/src/gmr.c 0000644 0001750 0001750 00000040556 12663426407 013750 0 ustar mbanck mbanck /*
* Copyright (C) 2010. See COPYRIGHT in top-level directory.
*/
#include
#include
#include
#include
#include
#include
#include
#include
#include
/** Linked list of shared memory regions.
*/
gmr_t *gmr_list = NULL;
/** Create a distributed shared memory region. Collective on ARMCI group.
*
* @param[in] local_size Size of the local slice of the memory region.
* @param[out] base_ptrs Array of base pointers for each process in group.
* @param[in] group Group on which to perform allocation.
* @return Pointer to the memory region object.
*/
gmr_t *gmr_create(gmr_size_t local_size, void **base_ptrs, ARMCI_Group *group) {
int i;
gmr_size_t aggregate_size;
int alloc_me, alloc_nproc;
int world_me, world_nproc;
MPI_Group world_group, alloc_group;
gmr_t *mreg;
gmr_slice_t *alloc_slices, gmr_slice;
ARMCII_Assert(local_size >= 0);
ARMCII_Assert(group != NULL);
MPI_Comm_rank(group->comm, &alloc_me);
MPI_Comm_size(group->comm, &alloc_nproc);
MPI_Comm_rank(ARMCI_GROUP_WORLD.comm, &world_me);
MPI_Comm_size(ARMCI_GROUP_WORLD.comm, &world_nproc);
mreg = malloc(sizeof(gmr_t));
ARMCII_Assert(mreg != NULL);
mreg->slices = malloc(sizeof(gmr_slice_t)*world_nproc);
ARMCII_Assert(mreg->slices != NULL);
alloc_slices = malloc(sizeof(gmr_slice_t)*alloc_nproc);
ARMCII_Assert(alloc_slices != NULL);
mreg->group = *group; /* NOTE: I think it is invalid in GA/ARMCI to
free a group before its allocations. If
this is not the case, then assignment here
is incorrect and this should really
duplicated the group (communicator). */
mreg->nslices = world_nproc;
mreg->prev = NULL;
mreg->next = NULL;
/* Allocate my slice of the GMR */
alloc_slices[alloc_me].size = local_size;
MPI_Info alloc_shm_info;
if (ARMCII_GLOBAL_STATE.use_alloc_shm) {
MPI_Info_create(&alloc_shm_info);
MPI_Info_set(alloc_shm_info, "alloc_shm", "true");
} else /* no alloc_shm */ {
alloc_shm_info = MPI_INFO_NULL;
}
if (ARMCII_GLOBAL_STATE.use_win_allocate) {
MPI_Win_allocate( (MPI_Aint) local_size, 1, alloc_shm_info, group->comm, &(alloc_slices[alloc_me].base), &mreg->window);
if (local_size == 0) {
/* TODO: Is this necessary? Is it a good idea anymore? */
alloc_slices[alloc_me].base = NULL;
} else {
ARMCII_Assert(alloc_slices[alloc_me].base != NULL);
}
} else /* use win create */ {
if (local_size == 0) {
alloc_slices[alloc_me].base = NULL;
} else {
MPI_Alloc_mem(local_size, alloc_shm_info, &(alloc_slices[alloc_me].base));
ARMCII_Assert(alloc_slices[alloc_me].base != NULL);
}
MPI_Win_create(alloc_slices[alloc_me].base, (MPI_Aint) local_size, 1, MPI_INFO_NULL, group->comm, &mreg->window);
} /* win allocate/create */
if (ARMCII_GLOBAL_STATE.use_alloc_shm) {
MPI_Info_free(&alloc_shm_info);
}
/* Debugging: Zero out shared memory if enabled */
if (ARMCII_GLOBAL_STATE.debug_alloc && local_size > 0) {
ARMCII_Bzero(alloc_slices[alloc_me].base, local_size);
}
/* All-to-all on to build up slices vector */
gmr_slice = alloc_slices[alloc_me];
MPI_Allgather( &gmr_slice, sizeof(gmr_slice_t), MPI_BYTE,
alloc_slices, sizeof(gmr_slice_t), MPI_BYTE, group->comm);
/* Check for a global size 0 allocation */
for (i = aggregate_size = 0; i < alloc_nproc; i++) {
aggregate_size += alloc_slices[i].size;
}
/* Everyone asked for 0 bytes, return a NULL vector */
if (aggregate_size == 0) {
free(alloc_slices);
free(mreg->slices);
free(mreg);
for (i = 0; i < alloc_nproc; i++)
base_ptrs[i] = NULL;
return NULL;
}
/* Populate the base pointers array */
for (i = 0; i < alloc_nproc; i++)
base_ptrs[i] = alloc_slices[i].base;
/* We have to do lookup on global ranks, so shovel the contents of
alloc_slices into the mreg->slices array which is indexed by global rank. */
memset(mreg->slices, 0, sizeof(gmr_slice_t)*world_nproc);
MPI_Comm_group(ARMCI_GROUP_WORLD.comm, &world_group);
MPI_Comm_group(group->comm, &alloc_group);
for (i = 0; i < alloc_nproc; i++) {
int world_rank;
MPI_Group_translate_ranks(alloc_group, 1, &i, world_group, &world_rank);
mreg->slices[world_rank] = alloc_slices[i];
}
free(alloc_slices);
MPI_Group_free(&world_group);
MPI_Group_free(&alloc_group);
MPI_Win_lock_all((ARMCII_GLOBAL_STATE.rma_nocheck) ? MPI_MODE_NOCHECK : 0,
mreg->window);
{
void *attr_ptr;
int *attr_val;
int attr_flag;
/* this function will always return flag=false in MPI-2 */
MPI_Win_get_attr(mreg->window, MPI_WIN_MODEL, &attr_ptr, &attr_flag);
if (attr_flag) {
attr_val = (int*)attr_ptr;
if (world_me==0) {
if ( (*attr_val)==MPI_WIN_SEPARATE ) {
printf("MPI_WIN_MODEL = MPI_WIN_SEPARATE \n" );
} else if ( (*attr_val)==MPI_WIN_UNIFIED ) {
#ifdef DEBUG
printf("MPI_WIN_MODEL = MPI_WIN_UNIFIED \n" );
#endif
} else {
printf("MPI_WIN_MODEL = %d (not UNIFIED or SEPARATE) \n", *attr_val );
}
}
} else {
if (world_me==0)
printf("MPI_WIN_MODEL attribute missing \n");
}
}
/* Append the new region onto the region list */
if (gmr_list == NULL) {
gmr_list = mreg;
} else {
gmr_t *parent = gmr_list;
while (parent->next != NULL)
parent = parent->next;
parent->next = mreg;
mreg->prev = parent;
}
return mreg;
}
/** Destroy/free a shared memory region.
*
* @param[in] ptr Pointer within range of the segment (e.g. base pointer).
* @param[in] group Group on which to perform the free.
*/
void gmr_destroy(gmr_t *mreg, ARMCI_Group *group) {
int search_proc_in, search_proc_out, search_proc_out_grp;
void *search_base = NULL;
int alloc_me, alloc_nproc;
int world_me, world_nproc;
MPI_Comm_rank(group->comm, &alloc_me);
MPI_Comm_size(group->comm, &alloc_nproc);
MPI_Comm_rank(ARMCI_GROUP_WORLD.comm, &world_me);
MPI_Comm_size(ARMCI_GROUP_WORLD.comm, &world_nproc);
/* All-to-all exchange of a pair. This is so that we
* can support passing NULL into ARMCI_Free() which is permitted when a
* process allocates 0 bytes. Unfortunately, in this case we still need to
* identify the mem region and free it.
*/
if (mreg == NULL)
search_proc_in = -1;
else {
search_proc_in = world_me;
search_base = mreg->slices[world_me].base;
}
/* Collectively decide on who will provide the base address */
MPI_Allreduce(&search_proc_in, &search_proc_out, 1, MPI_INT, MPI_MAX, group->comm);
/* Everyone passed NULL. Nothing to free. */
if (search_proc_out < 0)
return;
/* Translate world rank to group rank */
search_proc_out_grp = ARMCII_Translate_absolute_to_group(group, search_proc_out);
/* Broadcast the base address */
MPI_Bcast(&search_base, sizeof(void*), MPI_BYTE, search_proc_out_grp, group->comm);
/* If we were passed NULL, look up the mem region using the pair */
if (mreg == NULL)
mreg = gmr_lookup(search_base, search_proc_out);
/* If it's still not found, the user may have passed the wrong group */
ARMCII_Assert_msg(mreg != NULL, "Could not locate the desired allocation");
/* Remove from the list of mem regions */
if (mreg->prev == NULL) {
ARMCII_Assert(gmr_list == mreg);
gmr_list = mreg->next;
if (mreg->next != NULL)
mreg->next->prev = NULL;
} else {
mreg->prev->next = mreg->next;
if (mreg->next != NULL)
mreg->next->prev = mreg->prev;
}
ARMCII_Assert_msg(mreg->window != MPI_WIN_NULL, "A non-null mreg contains a null window.");
MPI_Win_unlock_all(mreg->window);
/* Destroy the window and free all buffers */
MPI_Win_free(&mreg->window);
if (!ARMCII_GLOBAL_STATE.use_win_allocate) {
if (mreg->slices[world_me].base != NULL) {
MPI_Free_mem(mreg->slices[world_me].base);
}
}
free(mreg->slices);
free(mreg);
}
/** Destroy all memory regions (called by finalize).
*
* @return Number of mem regions destroyed.
*/
int gmr_destroy_all(void) {
int count = 0;
while (gmr_list != NULL) {
gmr_destroy(gmr_list, &gmr_list->group);
count++;
}
return count;
}
/** Lookup a shared memory region using an address and process id.
*
* @param[in] ptr Pointer within range of the segment (e.g. base pointer).
* @param[in] proc Process on which the data lives.
* @return Pointer to the mem region object.
*/
gmr_t *gmr_lookup(void *ptr, int proc) {
gmr_t *mreg;
mreg = gmr_list;
while (mreg != NULL) {
ARMCII_Assert(proc < mreg->nslices);
/* Jeff: Why is uint8_t used here? .base is (void*). */
if (proc < mreg->nslices) {
const uint8_t *base = mreg->slices[proc].base;
const gmr_size_t size = mreg->slices[proc].size;
if ((uint8_t*) ptr >= base && (uint8_t*) ptr < base + size)
break;
}
mreg = mreg->next;
}
return mreg;
}
/** One-sided put operation. Source buffer must be private.
*
* @param[in] mreg Memory region
* @param[in] src Source address (local)
* @param[in] dst Destination address (remote)
* @param[in] size Number of bytes to transfer
* @param[in] proc Absolute process id of target process
* @return 0 on success, non-zero on failure
*/
int gmr_put(gmr_t *mreg, void *src, void *dst, int size, int proc) {
ARMCII_Assert_msg(src != NULL, "Invalid local address");
return gmr_put_typed(mreg, src, size, MPI_BYTE, dst, size, MPI_BYTE, proc);
}
/** One-sided put operation with type arguments. Source buffer must be private.
*
* @param[in] mreg Memory region
* @param[in] src Address of source data
* @param[in] src_count Number of elements of the given type at the source
* @param[in] src_type MPI datatype of the source elements
* @param[in] dst Address of destination buffer
* @param[in] dst_count Number of elements of the given type at the destination
* @param[in] src_type MPI datatype of the destination elements
* @param[in] size Number of bytes to transfer
* @param[in] proc Absolute process id of target process
* @return 0 on success, non-zero on failure
*/
int gmr_put_typed(gmr_t *mreg, void *src, int src_count, MPI_Datatype src_type,
void *dst, int dst_count, MPI_Datatype dst_type, int proc) {
int grp_proc;
gmr_size_t disp;
MPI_Aint lb, extent;
grp_proc = ARMCII_Translate_absolute_to_group(&mreg->group, proc);
ARMCII_Assert(grp_proc >= 0);
ARMCII_Assert_msg(mreg->window != MPI_WIN_NULL, "A non-null mreg contains a null window.");
// Calculate displacement from beginning of the window
if (dst == MPI_BOTTOM)
disp = 0;
else
disp = (gmr_size_t) ((uint8_t*)dst - (uint8_t*)mreg->slices[proc].base);
// Perform checks
MPI_Type_get_true_extent(dst_type, &lb, &extent);
ARMCII_Assert_msg(disp >= 0 && disp < mreg->slices[proc].size, "Invalid remote address");
ARMCII_Assert_msg(disp + dst_count*extent <= mreg->slices[proc].size, "Transfer is out of range");
if (ARMCII_GLOBAL_STATE.rma_atomicity) {
MPI_Accumulate(src, src_count, src_type, grp_proc,
(MPI_Aint) disp, dst_count, dst_type, MPI_REPLACE, mreg->window);
} else {
MPI_Put(src, src_count, src_type, grp_proc,
(MPI_Aint) disp, dst_count, dst_type, mreg->window);
}
return 0;
}
/** One-sided get operation. Destination buffer must be private.
*
* @param[in] mreg Memory region
* @param[in] src Source address (remote)
* @param[in] dst Destination address (local)
* @param[in] size Number of bytes to transfer
* @param[in] proc Absolute process id of target process
* @return 0 on success, non-zero on failure
*/
int gmr_get(gmr_t *mreg, void *src, void *dst, int size, int proc) {
ARMCII_Assert_msg(dst != NULL, "Invalid local address");
return gmr_get_typed(mreg, src, size, MPI_BYTE, dst, size, MPI_BYTE, proc);
}
/** One-sided get operation with type arguments. Destination buffer must be private.
*
* @param[in] mreg Memory region
* @param[in] src Address of source data
* @param[in] src_count Number of elements of the given type at the source
* @param[in] src_type MPI datatype of the source elements
* @param[in] dst Address of destination buffer
* @param[in] dst_count Number of elements of the given type at the destination
* @param[in] src_type MPI datatype of the destination elements
* @param[in] size Number of bytes to transfer
* @param[in] proc Absolute process id of target process
* @return 0 on success, non-zero on failure
*/
int gmr_get_typed(gmr_t *mreg, void *src, int src_count, MPI_Datatype src_type,
void *dst, int dst_count, MPI_Datatype dst_type, int proc) {
int grp_proc;
gmr_size_t disp;
MPI_Aint lb, extent;
grp_proc = ARMCII_Translate_absolute_to_group(&mreg->group, proc);
ARMCII_Assert(grp_proc >= 0);
ARMCII_Assert_msg(mreg->window != MPI_WIN_NULL, "A non-null mreg contains a null window.");
// Calculate displacement from beginning of the window
if (src == MPI_BOTTOM)
disp = 0;
else
disp = (gmr_size_t) ((uint8_t*)src - (uint8_t*)mreg->slices[proc].base);
// Perform checks
MPI_Type_get_true_extent(src_type, &lb, &extent);
ARMCII_Assert_msg(disp >= 0 && disp < mreg->slices[proc].size, "Invalid remote address");
ARMCII_Assert_msg(disp + src_count*extent <= mreg->slices[proc].size, "Transfer is out of range");
if (ARMCII_GLOBAL_STATE.rma_atomicity) {
MPI_Get_accumulate(NULL, 0, MPI_BYTE, dst, dst_count, dst_type, grp_proc,
(MPI_Aint) disp, src_count, src_type, MPI_NO_OP, mreg->window);
} else {
MPI_Get(dst, dst_count, dst_type, grp_proc,
(MPI_Aint) disp, src_count, src_type, mreg->window);
}
return 0;
}
/** One-sided accumulate operation. Source buffer must be private.
*
* @param[in] mreg Memory region
* @param[in] src Source address (local)
* @param[in] dst Destination address (remote)
* @param[in] type MPI type of the given buffers
* @param[in] count Number of elements of the given type to transfer
* @param[in] proc Absolute process id of the target
* @return 0 on success, non-zero on failure
*/
int gmr_accumulate(gmr_t *mreg, void *src, void *dst, int count, MPI_Datatype type, int proc) {
ARMCII_Assert_msg(src != NULL, "Invalid local address");
return gmr_accumulate_typed(mreg, src, count, type, dst, count, type, proc);
}
/** One-sided accumulate operation with typed arguments. Source buffer must be private.
*
* @param[in] mreg Memory region
* @param[in] src Address of source data
* @param[in] src_count Number of elements of the given type at the source
* @param[in] src_type MPI datatype of the source elements
* @param[in] dst Address of destination buffer
* @param[in] dst_count Number of elements of the given type at the destination
* @param[in] dst_type MPI datatype of the destination elements
* @param[in] size Number of bytes to transfer
* @param[in] proc Absolute process id of target process
* @return 0 on success, non-zero on failure
*/
int gmr_accumulate_typed(gmr_t *mreg, void *src, int src_count, MPI_Datatype src_type,
void *dst, int dst_count, MPI_Datatype dst_type, int proc) {
int grp_proc;
gmr_size_t disp;
MPI_Aint lb, extent;
grp_proc = ARMCII_Translate_absolute_to_group(&mreg->group, proc);
ARMCII_Assert(grp_proc >= 0);
ARMCII_Assert_msg(mreg->window != MPI_WIN_NULL, "A non-null mreg contains a null window.");
// Calculate displacement from beginning of the window
if (dst == MPI_BOTTOM)
disp = 0;
else
disp = (gmr_size_t) ((uint8_t*)dst - (uint8_t*)mreg->slices[proc].base);
// Perform checks
MPI_Type_get_true_extent(dst_type, &lb, &extent);
ARMCII_Assert_msg(disp >= 0 && disp < mreg->slices[proc].size, "Invalid remote address");
ARMCII_Assert_msg(disp + dst_count*extent <= mreg->slices[proc].size, "Transfer is out of range");
MPI_Accumulate(src, src_count, src_type, grp_proc, (MPI_Aint) disp, dst_count, dst_type, MPI_SUM, mreg->window);
return 0;
}
armci-mpi/src/gmr.h 0000644 0001750 0001750 00000004561 12663426407 013751 0 ustar mbanck mbanck /*
* Copyright (C) 2010. See COPYRIGHT in top-level directory.
*/
#ifndef HAVE_GMR_H
#define HAVE_GMR_H
#include
#include
#include
typedef armci_size_t gmr_size_t;
typedef struct {
void *base;
gmr_size_t size;
} gmr_slice_t;
typedef struct gmr_s {
MPI_Win window; /* MPI Window for this GMR */
ARMCI_Group group; /* Copy of the ARMCI group on which this GMR was allocated */
struct gmr_s *prev; /* Linked list pointers for GMR list */
struct gmr_s *next;
gmr_slice_t *slices; /* Array of GMR slices for this allocation */
int nslices;
} gmr_t;
extern gmr_t *gmr_list;
gmr_t *gmr_create(gmr_size_t local_size, void **base_ptrs, ARMCI_Group *group);
void gmr_destroy(gmr_t *mreg, ARMCI_Group *group);
int gmr_destroy_all(void);
gmr_t *gmr_lookup(void *ptr, int proc);
int gmr_get(gmr_t *mreg, void *src, void *dst, int size, int target);
int gmr_put(gmr_t *mreg, void *src, void *dst, int size, int target);
int gmr_accumulate(gmr_t *mreg, void *src, void *dst, int count, MPI_Datatype type, int proc);
int gmr_get_accumulate(gmr_t *mreg, void *src, void *out, void *dst, int count, MPI_Datatype type,
MPI_Op op, int proc);
int gmr_fetch_and_op(gmr_t *mreg, void *src, void *out, void *dst, MPI_Datatype type, MPI_Op op, int proc);
int gmr_get_typed(gmr_t *mreg, void *src, int src_count, MPI_Datatype src_type,
void *dst, int dst_count, MPI_Datatype dst_type, int proc);
int gmr_put_typed(gmr_t *mreg, void *src, int src_count, MPI_Datatype src_type,
void *dst, int dst_count, MPI_Datatype dst_type, int proc);
int gmr_accumulate_typed(gmr_t *mreg, void *src, int src_count, MPI_Datatype src_type,
void *dst, int dst_count, MPI_Datatype dst_type, int proc);
int gmr_get_accumulate_typed(gmr_t *mreg, void *src, int src_count, MPI_Datatype src_type,
void *out, int out_count, MPI_Datatype out_type, void *dst, int dst_count, MPI_Datatype dst_type,
MPI_Op op, int proc);
int gmr_lockall(gmr_t *mreg);
int gmr_unlockall(gmr_t *mreg);
int gmr_flush(gmr_t *mreg, int proc, int local_only);
int gmr_flushall(gmr_t *mreg, int local_only);
int gmr_sync(gmr_t *mreg);
void gmr_progress(void);
#endif /* HAVE_GMR_H */
armci-mpi/src/gmr-extras.c 0000644 0001750 0001750 00000017077 12663426407 015256 0 ustar mbanck mbanck /*
* Copyright (C) 2010. See COPYRIGHT in top-level directory.
*/
#include
#include
#include
#include
#include
#include
#include
#include
#include
/** One-sided get-accumulate operation. Source and output buffer must be private.
*
* @param[in] mreg Memory region
* @param[in] src Source address (local)
* @param[in] out Result address (local)
* @param[in] dst Destination address (remote)
* @param[in] type MPI type of the given buffers
* @param[in] count Number of elements of the given type to transfer
* @param[in] op MPI_Op to apply at the destination
* @param[in] proc Absolute process id of the target
* @return 0 on success, non-zero on failure
*/
int gmr_get_accumulate(gmr_t *mreg, void *src, void *out, void *dst, int count, MPI_Datatype type, MPI_Op op, int proc) {
ARMCII_Assert_msg(src != NULL && out != NULL, "Invalid local address(es)");
return gmr_get_accumulate_typed(mreg, src, count, type, out, count, type, dst, count, type, op, proc);
}
/** One-sided get-accumulate operation with typed arguments. Source and output buffer must be private.
*
* @param[in] mreg Memory region
* @param[in] src Address of source data
* @param[in] src_count Number of elements of the given type at the source
* @param[in] src_type MPI datatype of the source elements
* @param[in] out Address of output buffer (same process as the source)
* @param[in] out_count Number of elements of the given type at the ouput
* @param[in] out_type MPI datatype of the output elements
* @param[in] dst Address of destination buffer
* @param[in] dst_count Number of elements of the given type at the destination
* @param[in] dst_type MPI datatype of the destination elements
* @param[in] size Number of bytes to transfer
* @param[in] op MPI_Op to apply at the destination
* @param[in] proc Absolute process id of target process
* @return 0 on success, non-zero on failure
*/
int gmr_get_accumulate_typed(gmr_t *mreg, void *src, int src_count, MPI_Datatype src_type,
void *out, int out_count, MPI_Datatype out_type,
void *dst, int dst_count, MPI_Datatype dst_type, MPI_Op op, int proc) {
int grp_proc;
gmr_size_t disp;
MPI_Aint lb, extent;
grp_proc = ARMCII_Translate_absolute_to_group(&mreg->group, proc);
ARMCII_Assert(grp_proc >= 0);
ARMCII_Assert_msg(mreg->window != MPI_WIN_NULL, "A non-null mreg contains a null window.");
// Calculate displacement from beginning of the window
if (dst == MPI_BOTTOM)
disp = 0;
else
disp = (gmr_size_t) ((uint8_t*)dst - (uint8_t*)mreg->slices[proc].base);
// Perform checks
MPI_Type_get_true_extent(dst_type, &lb, &extent);
ARMCII_Assert_msg(disp >= 0 && disp < mreg->slices[proc].size, "Invalid remote address");
ARMCII_Assert_msg(disp + dst_count*extent <= mreg->slices[proc].size, "Transfer is out of range");
MPI_Get_accumulate(src, src_count, src_type, out, out_count, out_type, grp_proc, (MPI_Aint) disp, dst_count, dst_type, op, mreg->window);
return 0;
}
/** One-sided fetch-and-op. Source and output buffer must be private.
*
* @param[in] mreg Memory region
* @param[in] src Address of source data
* @param[in] out Address of output buffer (same process as the source)
* @param[in] dst Address of destination buffer
* @param[in] type MPI datatype of the source, output and destination elements
* @param[in] op MPI_Op to apply at the destination
* @param[in] proc Absolute process id of target process
* @return 0 on success, non-zero on failure
*/
int gmr_fetch_and_op(gmr_t *mreg, void *src, void *out, void *dst,
MPI_Datatype type, MPI_Op op, int proc) {
int grp_proc;
gmr_size_t disp;
grp_proc = ARMCII_Translate_absolute_to_group(&mreg->group, proc);
ARMCII_Assert(grp_proc >= 0);
ARMCII_Assert_msg(mreg->window != MPI_WIN_NULL, "A non-null mreg contains a null window.");
/* built-in types only so no chance of seeing MPI_BOTTOM */
disp = (gmr_size_t) ((uint8_t*)dst - (uint8_t*)mreg->slices[proc].base);
// Perform checks
ARMCII_Assert_msg(disp >= 0 && disp < mreg->slices[proc].size, "Invalid remote address");
ARMCII_Assert_msg(disp <= mreg->slices[proc].size, "Transfer is out of range");
MPI_Fetch_and_op(src, out, type, grp_proc, (MPI_Aint) disp, op, mreg->window);
return 0;
}
/** Lock a memory region at all targets so that one-sided operations can be performed.
*
* @param[in] mreg Memory region
* @return 0 on success, non-zero on failure
*/
int gmr_lockall(gmr_t *mreg) {
int grp_me = ARMCII_Translate_absolute_to_group(&mreg->group, ARMCI_GROUP_WORLD.rank);
ARMCII_Assert(grp_me >= 0);
ARMCII_Assert_msg(mreg->window != MPI_WIN_NULL, "A non-null mreg contains a null window.");
MPI_Win_lock_all((ARMCII_GLOBAL_STATE.rma_nocheck) ? MPI_MODE_NOCHECK : 0,
mreg->window);
return 0;
}
/** Unlock a memory region at all targets.
*
* @param[in] mreg Memory region
* @return 0 on success, non-zero on failure
*/
int gmr_unlockall(gmr_t *mreg) {
int grp_me = ARMCII_Translate_absolute_to_group(&mreg->group, ARMCI_GROUP_WORLD.rank);
ARMCII_Assert(grp_me >= 0);
ARMCII_Assert_msg(mreg->window != MPI_WIN_NULL, "A non-null mreg contains a null window.");
MPI_Win_unlock_all(mreg->window);
return 0;
}
/** Flush a memory region for local or remote completion.
*
* @param[in] mreg Memory region
* @param[in] proc Absolute process id of the target
* @param[in] local_only Only flush the operation locally.
* @return 0 on success, non-zero on failure
*/
int gmr_flush(gmr_t *mreg, int proc, int local_only) {
int grp_proc = ARMCII_Translate_absolute_to_group(&mreg->group, proc);
int grp_me = ARMCII_Translate_absolute_to_group(&mreg->group, ARMCI_GROUP_WORLD.rank);
ARMCII_Assert(grp_proc >= 0 && grp_me >= 0);
ARMCII_Assert_msg(mreg->window != MPI_WIN_NULL, "A non-null mreg contains a null window.");
ARMCII_Assert_msg(grp_proc < mreg->group.size, "grp_proc exceeds group size!");
if (!local_only || ARMCII_GLOBAL_STATE.end_to_end_flush) {
MPI_Win_flush(grp_proc, mreg->window);
} else {
MPI_Win_flush_local(grp_proc, mreg->window);
}
return 0;
}
/** Flush a memory region for remote completion to all targets.
*
* @param[in] mreg Memory region
* @return 0 on success, non-zero on failure
*/
int gmr_flushall(gmr_t *mreg, int local_only) {
int grp_me = ARMCII_Translate_absolute_to_group(&mreg->group, ARMCI_GROUP_WORLD.rank);
ARMCII_Assert(grp_me >= 0);
ARMCII_Assert_msg(mreg->window != MPI_WIN_NULL, "A non-null mreg contains a null window.");
if (!local_only || ARMCII_GLOBAL_STATE.end_to_end_flush) {
MPI_Win_flush_all(mreg->window);
} else {
MPI_Win_flush_local_all(mreg->window);
}
return 0;
}
/** Sync memory region so that public and private windows are the same.
*
* @param[in] mreg Memory region
* @return 0 on success, non-zero on failure
*/
int gmr_sync(gmr_t *mreg) {
int grp_me = ARMCII_Translate_absolute_to_group(&mreg->group, ARMCI_GROUP_WORLD.rank);
ARMCII_Assert(grp_me >= 0);
ARMCII_Assert_msg(mreg->window != MPI_WIN_NULL, "A non-null mreg contains a null window.");
MPI_Win_sync(mreg->window);
return 0;
}
void gmr_progress(void)
{
int flag;
MPI_Iprobe(MPI_ANY_SOURCE, MPI_ANY_TAG, ARMCI_GROUP_WORLD.comm, &flag, MPI_STATUS_IGNORE);
return;
}
armci-mpi/src/debug.h 0000644 0001750 0001750 00000003335 12662706250 014244 0 ustar mbanck mbanck /*
* Copyright (C) 2010. See COPYRIGHT in top-level directory.
*/
#ifndef _DEBUG_H_
#define _DEBUG_H_
#include
#include
#include
enum debug_cats_e {
DEBUG_CAT_ALL = -1,
DEBUG_CAT_NONE = 0,
DEBUG_CAT_MEM_REGION = 0x1, // 2^0
DEBUG_CAT_ALLOC = 0x2, // 2^1
DEBUG_CAT_MUTEX = 0x4, // 2^2
DEBUG_CAT_GROUPS = 0x8, // 2^3
DEBUG_CAT_CTREE = 0x10, // 2^4, ...
DEBUG_CAT_IOV = 0x20
};
/* A logical OR of the debug message categories that are enabled.
*/
extern unsigned DEBUG_CATS_ENABLED;
#ifdef NO_SEATBELTS
#define ARMCII_Assert(X) ((void)0)
#define ARMCII_Assert_msg(X,MSG) ((void)0)
#else
void ARMCII_Assert_fail(const char *expr, const char *msg, const char *file, int line, const char *func);
#define ARMCII_Assert(EXPR) do { if (unlikely(!(EXPR))) ARMCII_Assert_fail(#EXPR, NULL, __FILE__, __LINE__, __func__); } while(0)
#define ARMCII_Assert_msg(EXPR, MSG) do { if (unlikely(!(EXPR))) ARMCII_Assert_fail(#EXPR, MSG, __FILE__, __LINE__, __func__); } while(0)
#endif /* NO_SEATBELTS */
#ifdef NO_SEATBELTS
#define DEBUG_CAT_ENABLED(X) 0
#define ARMCII_Dbg_print(CAT,...) ((void)0)
#else
#define DEBUG_CAT_ENABLED(X) (DEBUG_CATS_ENABLED & (X))
void ARMCII_Dbg_print_impl(const char *func, const char *format, ...);
#define ARMCII_Dbg_print(CAT,...) do { if (DEBUG_CAT_ENABLED(CAT)) ARMCII_Dbg_print_impl(__func__,__VA_ARGS__); } while (0)
#endif /* NO_SEATBELTS */
#define ARMCII_Error(...) ARMCII_Error_impl(__FILE__,__LINE__,__func__,__VA_ARGS__)
void ARMCII_Error_impl(const char *file, const int line, const char *func, const char *msg, ...);
void ARMCII_Warning(const char *fmt, ...);
#endif /* _DEBUG_H_ */
armci-mpi/src/conflict_tree.c 0000644 0001750 0001750 00000020430 12662706250 015764 0 ustar mbanck mbanck /** Copyright (C) 2010. See COPYRIGHT in top-level directory.
*
* Conflict Tree -- James Dinan
*
* Conflict trees are used by ARMCI-MPI to detect conflicting accesses due to
* overlapping memory regions.
*
* This implementation uses an AVL tree which is a self-balancing binary tree.
* In contrast with interval and segment trees which can store mutiple
* overlapping regions and support stabbing queries, the conflict tree does
* not allow any overlap among elements in the tree. If an overlapping insert
* is performed, it will fail. Thus, objects in the tree are totally ordered
* and a standard binary tree (in this case, the AVL tree) is sufficient for
* detecting conflicts.
*/
#include
#include
#include
#include
#define MAX(A,B) (((A) > (B)) ? A : B)
static ctree_t ctree_balance(ctree_t node);
static void ctree_destroy_rec(ctree_t root);
static inline int ctree_node_height(ctree_t node);
static inline void ctree_rotate_left(ctree_t node);
static inline void ctree_rotate_right(ctree_t node);
const ctree_t CTREE_EMPTY = NULL;
/** Locate the node that conflicts with the given address range.
*
* @param[in] root Root of the ctree.
* @param[in] lo Low end of the range.
* @param[in] hi High end of the range.
* @return Pointer to the ctree node or NULL if not found.
*/
ctree_t ctree_locate(ctree_t root, uint8_t *lo, uint8_t *hi) {
ctree_t cur = root;
while (cur != NULL) {
if ( (lo >= cur->lo && lo <= cur->hi)
|| (hi >= cur->lo && hi <= cur->hi)
|| (lo < cur->lo && hi > cur->hi))
break;
else if (lo < cur->lo)
cur = cur->left;
else /* lo > cur->hi */
cur = cur->right;
}
return cur;
}
/** Insert an address range into the conflict detection tree.
*
* @param[inout] root The root of the tree
* @param[in] lo Lower bound of the address range
* @param[in] hi Upper bound of the address range
* @return Zero on success, nonzero when a conflict is detected.
* When a conflict exists, the range is not added.
*/
int ctree_insert(ctree_t *root, uint8_t *lo, uint8_t *hi) {
ctree_t cur;
ctree_t new_node = (ctree_t) malloc(sizeof(struct ctree_node_s));
new_node->lo = lo;
new_node->hi = hi;
new_node->height = 1;
new_node->parent = NULL;
new_node->left = NULL;
new_node->right = NULL;
cur = *root;
// CASE: Empty tree
if (cur == NULL) {
*root = new_node;
return 0;
}
for (;;) {
// Check for conflicts as we go
if ( (lo >= cur->lo && lo <= cur->hi)
|| (hi >= cur->lo && hi <= cur->hi)
|| (lo < cur->lo && hi > cur->hi)) {
ARMCII_Dbg_print(DEBUG_CAT_CTREE, "Conflict inserting [%p, %p] with [%p, %p]\n", lo, hi, cur->lo, cur->hi);
free(new_node);
return 1;
}
// Place in left subtree
else if (lo < cur->lo) {
if (cur->left == NULL) {
new_node->parent = cur;
cur->left = new_node;
*root = ctree_balance(cur);
return 0;
} else {
cur = cur->left;
}
}
// Place in right subtree
else /* lo > cur->hi */ {
if (cur->right == NULL) {
new_node->parent = cur;
cur->right = new_node;
*root = ctree_balance(cur);
return 0;
} else {
cur = cur->right;
}
}
}
}
/** Rotate the given pivot node to the left.
*
* @param[in] node This is the pivot node, it will be the new subtree root
* after the rotation is performed.
*/
static inline void ctree_rotate_left(ctree_t node) {
ctree_t old_root = node->parent;
//ARMCII_Dbg_print(DEBUG_CAT_CTREE, "[%10p, %10p] l=%d r=%d\n", node->lo, node->hi,
// ctree_node_height(node->left), ctree_node_height(node->right));
ARMCII_Assert(old_root->right == node);
// Set the parent pointer
node->parent = old_root->parent;
// Set the parent's child pointer
if (node->parent != NULL) {
if (node->parent->left == old_root)
node->parent->left = node;
else
node->parent->right = node;
}
// Set child pointers and their parents
old_root->right = node->left;
if (old_root->right != NULL)
old_root->right->parent = old_root;
node->left = old_root;
node->left->parent = node;
old_root->height = MAX(ctree_node_height(old_root->left), ctree_node_height(old_root->right)) + 1;
node->height = MAX(ctree_node_height(node->left), ctree_node_height(node->right)) + 1;
}
/** Rotate the given pivot node to the right.
*
* @param[in] node This is the pivot node, it will be the new subtree root
* after the rotation is performed.
*/
static inline void ctree_rotate_right(ctree_t node) {
ctree_t old_root = node->parent;
//ARMCII_Dbg_print(DEBUG_CAT_CTREE, "[%10p, %10p] l=%d r=%d\n", node->lo, node->hi,
// ctree_node_height(node->left), ctree_node_height(node->right));
ARMCII_Assert(old_root->left == node);
// Set the parent pointer
node->parent = old_root->parent;
// Set the parent's child pointer
if (node->parent != NULL) {
if (node->parent->left == old_root)
node->parent->left = node;
else
node->parent->right = node;
}
// Set child pointers and their parents
old_root->left = node->right;
if (old_root->left != NULL)
old_root->left->parent = old_root;
node->right = old_root;
node->right->parent = node;
old_root->height = MAX(ctree_node_height(old_root->left), ctree_node_height(old_root->right)) + 1;
node->height = MAX(ctree_node_height(node->left), ctree_node_height(node->right)) + 1;
}
/** Fetch the height of a given node.
*/
static inline int ctree_node_height(ctree_t node) {
if (node == NULL)
return 0;
else
return node->height;
}
/** Rebalance the tree starting with the current node and proceeding
* upwards towards the root.
*/
static ctree_t ctree_balance(ctree_t node) {
ctree_t root = node;
while (node != NULL) {
int height_l = ctree_node_height(node->left);
int height_r = ctree_node_height(node->right);
node->height = MAX(ctree_node_height(node->left), ctree_node_height(node->right)) + 1;
// Rebalance to preserve the property that right and left heights
// differ by at most 1.
if (abs(height_l - height_r) >= 2) {
// CASE: Right is heavy
if (height_l - height_r == -2) {
int height_r_l = ctree_node_height(node->right->left);
int height_r_r = ctree_node_height(node->right->right);
// CASE: Right, right
if (height_r_l - height_r_r <= 0) {
node = node->right;
ctree_rotate_left(node);
}
// CASE: Right, left
else {
ctree_rotate_right(node->right->left);
node = node->right;
ctree_rotate_left(node);
}
// CASE: Left is heavy
} else if (height_l - height_r == 2) {
int height_l_l = ctree_node_height(node->left->left);
int height_l_r = ctree_node_height(node->left->right);
// CASE: Left, left
if (height_l_l - height_l_r >= 0) {
node = node->left;
ctree_rotate_right(node);
}
// CASE: Left, right
else {
ctree_rotate_left(node->left->right);
node = node->left;
ctree_rotate_right(node);
}
} else {
ARMCII_Error("CTree invariant violated, height difference of %d is too large", height_l - height_r);
}
}
root = node;
node = node->parent;
}
return root;
}
/** Recursive function to traverse a tree and destroy all its nodes.
*/
static void ctree_destroy_rec(ctree_t root) {
if (root == NULL) return;
ctree_destroy_rec(root->left);
ctree_destroy_rec(root->right);
free(root);
}
/** Destroy a conflict tree.
*/
void ctree_destroy(ctree_t *root) {
ctree_destroy_rec(*root);
*root = NULL;
}
/** Print out the contents of the conflict detection tree.
*/
void ctree_print(ctree_t root) {
if (root != NULL) {
int i,idx;
char s[32] = "";
ctree_print(root->left);
for (i = 1, idx = 0; i < 32-1 && i < root->height; i++)
idx += sprintf(s+idx, "\t");
printf("%10p:%s[%p, %p] p=%p h=%d\n", (void*)root, s, root->lo, root->hi, (void*)(root->parent), root->height);
ctree_print(root->right);
}
}
armci-mpi/src/mutex.c 0000644 0001750 0001750 00000006306 12662706250 014314 0 ustar mbanck mbanck /*
* Copyright (C) 2010. See COPYRIGHT in top-level directory.
*/
#include