update mpich linux
This commit is contained in:
Bassem Girgis
Binary file not shown.
Binary file not shown.
Binary file not shown.
@@ -1,4 +1,4 @@
|
||||
#! /bin/bash
|
||||
#! /usr/bin/bash
|
||||
#
|
||||
# (C) 2006 by Argonne National Laboratory.
|
||||
# See COPYRIGHT in top-level directory.
|
||||
@@ -27,17 +27,17 @@
|
||||
#
|
||||
# Directory locations: Fixed for any MPI implementation.
|
||||
# Set from the directory arguments to configure (e.g., --prefix=/usr/local)
|
||||
prefix=/home/brgirgis/Documents/code/thirdparty/mpi/mpich_/build/../release_install
|
||||
exec_prefix=/home/brgirgis/Documents/code/thirdparty/mpi/mpich_/build/../release_install
|
||||
sysconfdir=/home/brgirgis/Documents/code/thirdparty/mpi/mpich_/build/../release_install/etc
|
||||
includedir=/home/brgirgis/Documents/code/thirdparty/mpi/mpich_/build/../release_install/include
|
||||
libdir=/home/brgirgis/Documents/code/thirdparty/mpi/mpich_/build/../release_install/lib64
|
||||
prefix=/home/brgirgis/Documents/code/idiscovery/cpp-thirdparty-src/mpi/mpich/install/3.3.1
|
||||
exec_prefix=/home/brgirgis/Documents/code/idiscovery/cpp-thirdparty-src/mpi/mpich/install/3.3.1
|
||||
sysconfdir=/home/brgirgis/Documents/code/idiscovery/cpp-thirdparty-src/mpi/mpich/install/3.3.1/etc
|
||||
includedir=/home/brgirgis/Documents/code/idiscovery/cpp-thirdparty-src/mpi/mpich/install/3.3.1/include
|
||||
libdir=/home/brgirgis/Documents/code/idiscovery/cpp-thirdparty-src/mpi/mpich/install/3.3.1/lib64
|
||||
|
||||
# Default settings for compiler, flags, and libraries.
|
||||
# Determined by a combination of environment variables and tests within
|
||||
# configure (e.g., determining whehter -lsocket is needee)
|
||||
CC="gcc"
|
||||
MPICH_VERSION="3.2.1"
|
||||
MPICH_VERSION="3.3.1"
|
||||
|
||||
enable_wrapper_rpath="yes"
|
||||
|
||||
@@ -117,6 +117,7 @@ linking=yes
|
||||
allargs=("$@")
|
||||
argno=0
|
||||
interlib_deps=yes
|
||||
static_mpi=no
|
||||
for arg in "$@" ; do
|
||||
# Set addarg to no if this arg should be ignored by the C compiler
|
||||
addarg=yes
|
||||
@@ -133,6 +134,11 @@ for arg in "$@" ; do
|
||||
-static)
|
||||
interlib_deps=no
|
||||
;;
|
||||
-static-mpi)
|
||||
interlib_deps=no
|
||||
static_mpi=yes
|
||||
addarg=no
|
||||
;;
|
||||
-echo)
|
||||
addarg=no
|
||||
set -x
|
||||
@@ -244,7 +250,7 @@ final_ldflags=" "
|
||||
final_libs=""
|
||||
if test "yes" = "no" -o "${interlib_deps}" = "no" ; then
|
||||
final_ldflags="${final_ldflags} "
|
||||
final_libs="${final_libs} -lpthread -lrt -lpthread "
|
||||
final_libs="${final_libs} -lm -lpthread -lrt "
|
||||
fi
|
||||
|
||||
# -----------------------------------------------------------------------
|
||||
@@ -275,7 +281,20 @@ if [ "$linking" = yes ] ; then
|
||||
$Show $CC ${final_cppflags} $PROFILE_INCPATHS ${final_cflags} ${final_ldflags} "${allargs[@]}" -I$includedir
|
||||
rc=$?
|
||||
else
|
||||
if [ "$static_mpi" = no ] ; then
|
||||
$Show $CC ${final_cppflags} $PROFILE_INCPATHS ${final_cflags} ${final_ldflags} "${allargs[@]}" -I$includedir -L$libdir $PROFILE_PRELIB $PROFILE_FOO $rpath_flags -lmpi $PROFILE_POSTLIB ${final_libs}
|
||||
else
|
||||
fabric_dep=""
|
||||
if [ "" = yes ] ; then
|
||||
fabric_dep=`pkg-config --static --libs $libdir/pkgconfig/libfabric.pc`
|
||||
fabric_dep=`echo $fabric_dep | sed 's/-lfabric//'`
|
||||
elif [ -f /lib/pkgconfig/libfabric.pc ] ; then
|
||||
fabric_dep=`pkg-config --static --libs /lib/pkgconfig/libfabric.pc`
|
||||
else
|
||||
fabric_dep=`pkg-config --static --libs libfabric`
|
||||
fi
|
||||
$Show $CC ${final_cppflags} $PROFILE_INCPATHS ${final_cflags} ${final_ldflags} "${allargs[@]}" -I$includedir -L$libdir $PROFILE_PRELIB $PROFILE_FOO $rpath_flags $libdir/libmpi.a $PROFILE_POSTLIB ${final_libs} ${fabric_dep}
|
||||
fi
|
||||
rc=$?
|
||||
fi
|
||||
else
|
||||
|
||||
Binary file not shown.
Binary file not shown.
Binary file not shown.
File diff suppressed because it is too large
Load Diff
@@ -12,6 +12,12 @@
|
||||
|
||||
#include "mpi.h"
|
||||
|
||||
#if defined(HAVE_VISIBILITY)
|
||||
#define ROMIO_API_PUBLIC __attribute__((visibility ("default")))
|
||||
#else
|
||||
#define ROMIO_API_PUBLIC
|
||||
#endif
|
||||
|
||||
#if defined(__cplusplus)
|
||||
extern "C" {
|
||||
#endif
|
||||
@@ -24,7 +30,9 @@ extern "C" {
|
||||
typedef struct ADIOI_FileD *MPI_File;
|
||||
#endif
|
||||
|
||||
/* *INDENT-OFF* */
|
||||
#define HAVE_MPI_GREQUEST 1
|
||||
/* *INDENT-ON* */
|
||||
#ifndef HAVE_MPI_GREQUEST
|
||||
typedef struct ADIOI_RequestD *MPIO_Request;
|
||||
#else
|
||||
@@ -39,7 +47,9 @@ typedef struct ADIOI_RequestD *MPIO_Request;
|
||||
#define MPIO_REQUEST_DEFINED
|
||||
|
||||
#ifndef HAVE_MPI_OFFSET
|
||||
/* *INDENT-OFF* */
|
||||
typedef long long MPI_Offset;
|
||||
/* *INDENT-ON* */
|
||||
/* If we needed to define MPI_Offset, then we also need to make
|
||||
this definition. */
|
||||
#ifndef HAVE_MPI_DATAREP_FUNCTIONS
|
||||
@@ -52,14 +62,18 @@ typedef int (MPI_Datarep_extent_function)(MPI_Datatype datatype, MPI_Aint *,
|
||||
#endif
|
||||
|
||||
#ifndef NEEDS_MPI_FINT
|
||||
/* *INDENT-OFF* */
|
||||
|
||||
/* *INDENT-ON* */
|
||||
#endif
|
||||
#ifdef NEEDS_MPI_FINT
|
||||
typedef int MPI_Fint;
|
||||
#endif
|
||||
|
||||
#ifndef HAVE_MPI_INFO
|
||||
/* *INDENT-OFF* */
|
||||
#define HAVE_MPI_INFO
|
||||
/* *INDENT-ON* */
|
||||
#endif
|
||||
#ifndef HAVE_MPI_INFO
|
||||
typedef struct MPIR_Info *MPI_Info;
|
||||
@@ -99,7 +113,9 @@ typedef int MPI_Fint;
|
||||
#endif
|
||||
|
||||
#ifndef HAVE_MPI_DARRAY_SUBARRAY
|
||||
/* *INDENT-OFF* */
|
||||
#define HAVE_MPI_DARRAY_SUBARRAY
|
||||
/* *INDENT-ON* */
|
||||
#endif
|
||||
#ifndef HAVE_MPI_DARRAY_SUBARRAY
|
||||
# define MPI_ORDER_C 56
|
||||
@@ -120,150 +136,150 @@ typedef int MPI_Fint;
|
||||
|
||||
/* Section 9.2 */
|
||||
/* Begin Prototypes */
|
||||
int MPI_File_open(MPI_Comm comm, const char *filename, int amode, MPI_Info info, MPI_File *fh);
|
||||
int MPI_File_close(MPI_File *fh);
|
||||
int MPI_File_delete(const char *filename, MPI_Info info);
|
||||
int MPI_File_set_size(MPI_File fh, MPI_Offset size);
|
||||
int MPI_File_preallocate(MPI_File fh, MPI_Offset size);
|
||||
int MPI_File_get_size(MPI_File fh, MPI_Offset *size);
|
||||
int MPI_File_get_group(MPI_File fh, MPI_Group *group);
|
||||
int MPI_File_get_amode(MPI_File fh, int *amode);
|
||||
int MPI_File_set_info(MPI_File fh, MPI_Info info);
|
||||
int MPI_File_get_info(MPI_File fh, MPI_Info *info_used);
|
||||
int MPI_File_open(MPI_Comm comm, const char *filename, int amode, MPI_Info info, MPI_File *fh) ROMIO_API_PUBLIC;
|
||||
int MPI_File_close(MPI_File *fh) ROMIO_API_PUBLIC;
|
||||
int MPI_File_delete(const char *filename, MPI_Info info) ROMIO_API_PUBLIC;
|
||||
int MPI_File_set_size(MPI_File fh, MPI_Offset size) ROMIO_API_PUBLIC;
|
||||
int MPI_File_preallocate(MPI_File fh, MPI_Offset size) ROMIO_API_PUBLIC;
|
||||
int MPI_File_get_size(MPI_File fh, MPI_Offset *size) ROMIO_API_PUBLIC;
|
||||
int MPI_File_get_group(MPI_File fh, MPI_Group *group) ROMIO_API_PUBLIC;
|
||||
int MPI_File_get_amode(MPI_File fh, int *amode) ROMIO_API_PUBLIC;
|
||||
int MPI_File_set_info(MPI_File fh, MPI_Info info) ROMIO_API_PUBLIC;
|
||||
int MPI_File_get_info(MPI_File fh, MPI_Info *info_used) ROMIO_API_PUBLIC;
|
||||
|
||||
/* Section 9.3 */
|
||||
int MPI_File_set_view(MPI_File fh, MPI_Offset disp, MPI_Datatype etype, MPI_Datatype filetype,
|
||||
const char *datarep, MPI_Info info);
|
||||
const char *datarep, MPI_Info info) ROMIO_API_PUBLIC;
|
||||
int MPI_File_get_view(MPI_File fh, MPI_Offset *disp, MPI_Datatype *etype, MPI_Datatype *filetype,
|
||||
char *datarep);
|
||||
char *datarep) ROMIO_API_PUBLIC;
|
||||
|
||||
/* Section 9.4.2 */
|
||||
int MPI_File_read_at(MPI_File fh, MPI_Offset offset, void *buf, int count, MPI_Datatype datatype,
|
||||
MPI_Status *status) MPICH_ATTR_POINTER_WITH_TYPE_TAG(3,5);
|
||||
MPI_Status *status) MPICH_ATTR_POINTER_WITH_TYPE_TAG(3,5) ROMIO_API_PUBLIC;
|
||||
int MPI_File_read_at_all(MPI_File fh, MPI_Offset offset, void * buf, int count,
|
||||
MPI_Datatype datatype, MPI_Status *status)
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(3,5);
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(3,5) ROMIO_API_PUBLIC;
|
||||
int MPI_File_write_at(MPI_File fh, MPI_Offset offset, const void * buf, int count,
|
||||
MPI_Datatype datatype, MPI_Status *status)
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(3,5);
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(3,5) ROMIO_API_PUBLIC;
|
||||
int MPI_File_write_at_all(MPI_File fh, MPI_Offset offset, const void *buf, int count,
|
||||
MPI_Datatype datatype, MPI_Status *status)
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(3,5);
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(3,5) ROMIO_API_PUBLIC;
|
||||
|
||||
/* nonblocking calls currently use MPIO_Request, because generalized
|
||||
requests not yet implemented. For the same reason, MPIO_Test and
|
||||
MPIO_Wait are used to test and wait on nonblocking I/O requests */
|
||||
int MPI_File_iread_at(MPI_File fh, MPI_Offset offset, void *buf, int count, MPI_Datatype datatype,
|
||||
MPIO_Request *request) MPICH_ATTR_POINTER_WITH_TYPE_TAG(3,5);
|
||||
MPIO_Request *request) MPICH_ATTR_POINTER_WITH_TYPE_TAG(3,5) ROMIO_API_PUBLIC;
|
||||
int MPI_File_iwrite_at(MPI_File fh, MPI_Offset offset, const void *buf, int count,
|
||||
MPI_Datatype datatype, MPIO_Request *request)
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(3,5);
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(3,5) ROMIO_API_PUBLIC;
|
||||
|
||||
/* Section 9.4.3 */
|
||||
int MPI_File_read(MPI_File fh, void *buf, int count, MPI_Datatype datatype, MPI_Status *status)
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(2,4);
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(2,4) ROMIO_API_PUBLIC;
|
||||
int MPI_File_read_all(MPI_File fh, void *buf, int count, MPI_Datatype datatype, MPI_Status *status)
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(2,4);
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(2,4) ROMIO_API_PUBLIC;
|
||||
int MPI_File_write(MPI_File fh, const void *buf, int count, MPI_Datatype datatype,
|
||||
MPI_Status *status) MPICH_ATTR_POINTER_WITH_TYPE_TAG(2,4);
|
||||
MPI_Status *status) MPICH_ATTR_POINTER_WITH_TYPE_TAG(2,4) ROMIO_API_PUBLIC;
|
||||
int MPI_File_write_all(MPI_File fh, const void *buf, int count, MPI_Datatype datatype,
|
||||
MPI_Status *status) MPICH_ATTR_POINTER_WITH_TYPE_TAG(2,4);
|
||||
MPI_Status *status) MPICH_ATTR_POINTER_WITH_TYPE_TAG(2,4) ROMIO_API_PUBLIC;
|
||||
|
||||
/* nonblocking calls currently use MPIO_Request, because generalized
|
||||
requests not yet implemented. For the same reason, MPIO_Test and
|
||||
MPIO_Wait are used to test and wait on nonblocking I/O requests */
|
||||
|
||||
int MPI_File_iread(MPI_File fh, void *buf, int count, MPI_Datatype datatype, MPIO_Request *request)
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(2,4);
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(2,4) ROMIO_API_PUBLIC;
|
||||
int MPI_File_iwrite(MPI_File fh, const void *buf, int count, MPI_Datatype datatype,
|
||||
MPIO_Request *request) MPICH_ATTR_POINTER_WITH_TYPE_TAG(2,4);
|
||||
MPIO_Request *request) MPICH_ATTR_POINTER_WITH_TYPE_TAG(2,4) ROMIO_API_PUBLIC;
|
||||
|
||||
int MPI_File_seek(MPI_File fh, MPI_Offset offset, int whence);
|
||||
int MPI_File_get_position(MPI_File fh, MPI_Offset *offset);
|
||||
int MPI_File_get_byte_offset(MPI_File fh, MPI_Offset offset, MPI_Offset *disp);
|
||||
int MPI_File_seek(MPI_File fh, MPI_Offset offset, int whence) ROMIO_API_PUBLIC;
|
||||
int MPI_File_get_position(MPI_File fh, MPI_Offset *offset) ROMIO_API_PUBLIC;
|
||||
int MPI_File_get_byte_offset(MPI_File fh, MPI_Offset offset, MPI_Offset *disp) ROMIO_API_PUBLIC;
|
||||
|
||||
/* Section 9.4.4 */
|
||||
int MPI_File_read_shared(MPI_File fh, void *buf, int count, MPI_Datatype datatype,
|
||||
MPI_Status *status) MPICH_ATTR_POINTER_WITH_TYPE_TAG(2,4);
|
||||
MPI_Status *status) MPICH_ATTR_POINTER_WITH_TYPE_TAG(2,4) ROMIO_API_PUBLIC;
|
||||
int MPI_File_write_shared(MPI_File fh, const void *buf, int count, MPI_Datatype datatype,
|
||||
MPI_Status *status) MPICH_ATTR_POINTER_WITH_TYPE_TAG(2,4);
|
||||
MPI_Status *status) MPICH_ATTR_POINTER_WITH_TYPE_TAG(2,4) ROMIO_API_PUBLIC;
|
||||
int MPI_File_iread_shared(MPI_File fh, void *buf, int count, MPI_Datatype datatype,
|
||||
MPIO_Request *request) MPICH_ATTR_POINTER_WITH_TYPE_TAG(2,4);
|
||||
MPIO_Request *request) MPICH_ATTR_POINTER_WITH_TYPE_TAG(2,4) ROMIO_API_PUBLIC;
|
||||
int MPI_File_iwrite_shared(MPI_File fh, const void *buf, int count, MPI_Datatype datatype,
|
||||
MPIO_Request *request) MPICH_ATTR_POINTER_WITH_TYPE_TAG(2,4);
|
||||
MPIO_Request *request) MPICH_ATTR_POINTER_WITH_TYPE_TAG(2,4) ROMIO_API_PUBLIC;
|
||||
int MPI_File_read_ordered(MPI_File fh, void *buf, int count, MPI_Datatype datatype,
|
||||
MPI_Status *status) MPICH_ATTR_POINTER_WITH_TYPE_TAG(2,4);
|
||||
MPI_Status *status) MPICH_ATTR_POINTER_WITH_TYPE_TAG(2,4) ROMIO_API_PUBLIC;
|
||||
int MPI_File_write_ordered(MPI_File fh, const void *buf, int count, MPI_Datatype datatype,
|
||||
MPI_Status *status) MPICH_ATTR_POINTER_WITH_TYPE_TAG(2,4);
|
||||
int MPI_File_seek_shared(MPI_File fh, MPI_Offset offset, int whence);
|
||||
int MPI_File_get_position_shared(MPI_File fh, MPI_Offset *offset);
|
||||
MPI_Status *status) MPICH_ATTR_POINTER_WITH_TYPE_TAG(2,4) ROMIO_API_PUBLIC;
|
||||
int MPI_File_seek_shared(MPI_File fh, MPI_Offset offset, int whence) ROMIO_API_PUBLIC;
|
||||
int MPI_File_get_position_shared(MPI_File fh, MPI_Offset *offset) ROMIO_API_PUBLIC;
|
||||
|
||||
/* Section 9.4.5 */
|
||||
int MPI_File_read_at_all_begin(MPI_File fh, MPI_Offset offset, void *buf, int count,
|
||||
MPI_Datatype datatype) MPICH_ATTR_POINTER_WITH_TYPE_TAG(3,5);
|
||||
int MPI_File_read_at_all_end(MPI_File fh, void *buf, MPI_Status *status);
|
||||
MPI_Datatype datatype) MPICH_ATTR_POINTER_WITH_TYPE_TAG(3,5) ROMIO_API_PUBLIC;
|
||||
int MPI_File_read_at_all_end(MPI_File fh, void *buf, MPI_Status *status) ROMIO_API_PUBLIC;
|
||||
int MPI_File_write_at_all_begin(MPI_File fh, MPI_Offset offset, const void *buf, int count,
|
||||
MPI_Datatype datatype) MPICH_ATTR_POINTER_WITH_TYPE_TAG(3,5);
|
||||
int MPI_File_write_at_all_end(MPI_File fh, const void *buf, MPI_Status *status);
|
||||
MPI_Datatype datatype) MPICH_ATTR_POINTER_WITH_TYPE_TAG(3,5) ROMIO_API_PUBLIC;
|
||||
int MPI_File_write_at_all_end(MPI_File fh, const void *buf, MPI_Status *status) ROMIO_API_PUBLIC;
|
||||
int MPI_File_read_all_begin(MPI_File fh, void *buf, int count, MPI_Datatype datatype)
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(2,4);
|
||||
int MPI_File_read_all_end(MPI_File fh, void *buf, MPI_Status *status);
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(2,4) ROMIO_API_PUBLIC;
|
||||
int MPI_File_read_all_end(MPI_File fh, void *buf, MPI_Status *status) ROMIO_API_PUBLIC;
|
||||
int MPI_File_write_all_begin(MPI_File fh, const void *buf, int count, MPI_Datatype datatype)
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(2,4);
|
||||
int MPI_File_write_all_end(MPI_File fh, const void *buf, MPI_Status *status);
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(2,4) ROMIO_API_PUBLIC;
|
||||
int MPI_File_write_all_end(MPI_File fh, const void *buf, MPI_Status *status) ROMIO_API_PUBLIC;
|
||||
int MPI_File_read_ordered_begin(MPI_File fh, void *buf, int count, MPI_Datatype datatype)
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(2,4);
|
||||
int MPI_File_read_ordered_end(MPI_File fh, void *buf, MPI_Status *status);
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(2,4) ROMIO_API_PUBLIC;
|
||||
int MPI_File_read_ordered_end(MPI_File fh, void *buf, MPI_Status *status) ROMIO_API_PUBLIC;
|
||||
int MPI_File_write_ordered_begin(MPI_File fh, const void *buf, int count, MPI_Datatype datatype)
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(2,4);
|
||||
int MPI_File_write_ordered_end(MPI_File fh, const void *buf, MPI_Status *status);
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(2,4) ROMIO_API_PUBLIC;
|
||||
int MPI_File_write_ordered_end(MPI_File fh, const void *buf, MPI_Status *status) ROMIO_API_PUBLIC;
|
||||
|
||||
/* Section 9.5.1 */
|
||||
int MPI_File_get_type_extent(MPI_File fh, MPI_Datatype datatype, MPI_Aint *extent);
|
||||
int MPI_File_get_type_extent(MPI_File fh, MPI_Datatype datatype, MPI_Aint *extent) ROMIO_API_PUBLIC;
|
||||
|
||||
/* Section 9.5.3 */
|
||||
int MPI_Register_datarep(const char *datarep, MPI_Datarep_conversion_function *read_conversion_fn,
|
||||
MPI_Datarep_conversion_function *write_conversion_fn,
|
||||
MPI_Datarep_extent_function *dtype_file_extent_fn, void *extra_state);
|
||||
MPI_Datarep_extent_function *dtype_file_extent_fn, void *extra_state) ROMIO_API_PUBLIC;
|
||||
|
||||
/* Section 9.6.1 */
|
||||
int MPI_File_set_atomicity(MPI_File fh, int flag);
|
||||
int MPI_File_get_atomicity(MPI_File fh, int *flag);
|
||||
int MPI_File_sync(MPI_File fh);
|
||||
int MPI_File_set_atomicity(MPI_File fh, int flag) ROMIO_API_PUBLIC;
|
||||
int MPI_File_get_atomicity(MPI_File fh, int *flag) ROMIO_API_PUBLIC;
|
||||
int MPI_File_sync(MPI_File fh) ROMIO_API_PUBLIC;
|
||||
|
||||
/* Section 4.13.3 */
|
||||
#ifndef MPICH
|
||||
/* MPICH provides these definitions */
|
||||
int MPI_File_set_errhandler(MPI_File file, MPI_Errhandler errhandler);
|
||||
int MPI_File_get_errhandler(MPI_File file, MPI_Errhandler *errhandler);
|
||||
int MPI_File_set_errhandler(MPI_File file, MPI_Errhandler errhandler) ROMIO_API_PUBLIC;
|
||||
int MPI_File_get_errhandler(MPI_File file, MPI_Errhandler *errhandler) ROMIO_API_PUBLIC;
|
||||
#endif
|
||||
|
||||
/* For MPI 3.1 */
|
||||
int MPI_File_iread_at_all(MPI_File fh, MPI_Offset offset, void *buf, int count,
|
||||
MPI_Datatype datatype, MPI_Request *request)
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(3,5);
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(3,5) ROMIO_API_PUBLIC;
|
||||
int MPI_File_iwrite_at_all(MPI_File fh, MPI_Offset offset, const void *buf, int count,
|
||||
MPI_Datatype datatype, MPI_Request *request)
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(3,5);
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(3,5) ROMIO_API_PUBLIC;
|
||||
int MPI_File_iread_all(MPI_File fh, void *buf, int count, MPI_Datatype datatype,
|
||||
MPI_Request *request)
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(2,4);
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(2,4) ROMIO_API_PUBLIC;
|
||||
int MPI_File_iwrite_all(MPI_File fh, const void *buf, int count, MPI_Datatype datatype,
|
||||
MPI_Request *request)
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(2,4);
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(2,4) ROMIO_API_PUBLIC;
|
||||
/* End Prototypes */
|
||||
|
||||
#ifndef HAVE_MPI_DARRAY_SUBARRAY
|
||||
/* Section 4.14.4 */
|
||||
int MPI_Type_create_subarray(int ndims, const int array_of_sizes[], const int array_of_subsizes[],
|
||||
const int array_of_starts[], int order, MPI_Datatype oldtype,
|
||||
MPI_Datatype *newtype);
|
||||
MPI_Datatype *newtype) ROMIO_API_PUBLIC;
|
||||
|
||||
/* Section 4.14.5 */
|
||||
int MPI_Type_create_darray(int size, int rank, int ndims, const int array_of_gsizes[],
|
||||
const int array_of_distribs[], const int array_of_dargs[],
|
||||
const int array_of_psizes, int order, MPI_Datatype oldtype,
|
||||
MPI_Datatype *newtype);
|
||||
MPI_Datatype *newtype) ROMIO_API_PUBLIC;
|
||||
#endif
|
||||
|
||||
/* The globus2 device has to rename MPI_ symbols in order to use the vendor
|
||||
@@ -279,43 +295,43 @@ int MPI_Type_create_darray(int size, int rank, int ndims, const int array_of_gsi
|
||||
#endif
|
||||
#endif
|
||||
/* above needed for some versions of mpi.h in MPICH!! */
|
||||
MPI_File MPI_File_f2c(MPI_Fint file);
|
||||
MPI_Fint MPI_File_c2f(MPI_File file);
|
||||
MPI_File MPI_File_f2c(MPI_Fint file) ROMIO_API_PUBLIC;
|
||||
MPI_Fint MPI_File_c2f(MPI_File file) ROMIO_API_PUBLIC;
|
||||
|
||||
|
||||
#ifndef HAVE_MPI_GREQUEST
|
||||
/* The following functions are required if generalized requests are not
|
||||
available, because in that case, an MPIO_Request object
|
||||
is currently used for nonblocking I/O. */
|
||||
int MPIO_Test(MPIO_Request *request, int *flag, MPI_Status *status);
|
||||
int MPIO_Wait(MPIO_Request *request, MPI_Status *status);
|
||||
int MPIO_Test(MPIO_Request *request, int *flag, MPI_Status *status) ROMIO_API_PUBLIC;
|
||||
int MPIO_Wait(MPIO_Request *request, MPI_Status *status) ROMIO_API_PUBLIC;
|
||||
int MPIO_Testall(int count, MPIO_Request array_of_requests[], int *flag,
|
||||
MPI_Status array_of_statuses[]);
|
||||
int MPIO_Waitall(int count, MPIO_Request array_of_requests[], MPI_Status array_of_statuses[]);
|
||||
MPI_Status array_of_statuses[]) ROMIO_API_PUBLIC;
|
||||
int MPIO_Waitall(int count, MPIO_Request array_of_requests[], MPI_Status array_of_statuses[]) ROMIO_API_PUBLIC;
|
||||
int MPIO_Testany(int count, MPIO_Request array_of_requests[], int *indx, int *flag,
|
||||
MPI_Status *status);
|
||||
int MPIO_Waitany(int count, MPIO_Request array_of_requests[], int *indx, MPI_Status *status);
|
||||
MPI_Status *status) ROMIO_API_PUBLIC;
|
||||
int MPIO_Waitany(int count, MPIO_Request array_of_requests[], int *indx, MPI_Status *status) ROMIO_API_PUBLIC;
|
||||
int MPIO_Waitsome(int incount, MPIO_Request array_of_requests[], int *outcount,
|
||||
int array_of_indices[], MPI_Status array_of_statuses[]);
|
||||
int array_of_indices[], MPI_Status array_of_statuses[]) ROMIO_API_PUBLIC;
|
||||
int MPIO_Testsome(int incount, MPIO_Request array_of_requests[], int *outcount,
|
||||
int array_of_indices[], MPI_Status array_of_statuses[]);
|
||||
int array_of_indices[], MPI_Status array_of_statuses[]) ROMIO_API_PUBLIC;
|
||||
|
||||
MPI_Fint MPIO_Request_c2f(MPIO_Request request);
|
||||
MPIO_Request MPIO_Request_f2c(MPI_Fint request);
|
||||
MPI_Fint MPIO_Request_c2f(MPIO_Request request) ROMIO_API_PUBLIC;
|
||||
MPIO_Request MPIO_Request_f2c(MPI_Fint request) ROMIO_API_PUBLIC;
|
||||
#endif /* HAVE_MPI_GREQUEST */
|
||||
|
||||
/* info functions if not defined in the MPI implementation */
|
||||
#ifndef HAVE_MPI_INFO
|
||||
|
||||
int MPI_Info_create(MPI_Info *info);
|
||||
int MPI_Info_set(MPI_Info info, const char *key, const char *value);
|
||||
int MPI_Info_delete(MPI_Info info, const char *key);
|
||||
int MPI_Info_get(MPI_Info info, const char *key, int valuelen, char *value, int *flag);
|
||||
int MPI_Info_get_valuelen(MPI_Info info, const char *key, int *valuelen, int *flag);
|
||||
int MPI_Info_get_nkeys(MPI_Info info, int *nkeys);
|
||||
int MPI_Info_get_nthkey(MPI_Info info, int n, char *key);
|
||||
int MPI_Info_dup(MPI_Info info, MPI_Info *newinfo);
|
||||
int MPI_Info_free(MPI_Info *info);
|
||||
int MPI_Info_create(MPI_Info *info) ROMIO_API_PUBLIC;
|
||||
int MPI_Info_set(MPI_Info info, const char *key, const char *value) ROMIO_API_PUBLIC;
|
||||
int MPI_Info_delete(MPI_Info info, const char *key) ROMIO_API_PUBLIC;
|
||||
int MPI_Info_get(MPI_Info info, const char *key, int valuelen, char *value, int *flag) ROMIO_API_PUBLIC;
|
||||
int MPI_Info_get_valuelen(MPI_Info info, const char *key, int *valuelen, int *flag) ROMIO_API_PUBLIC;
|
||||
int MPI_Info_get_nkeys(MPI_Info info, int *nkeys) ROMIO_API_PUBLIC;
|
||||
int MPI_Info_get_nthkey(MPI_Info info, int n, char *key) ROMIO_API_PUBLIC;
|
||||
int MPI_Info_dup(MPI_Info info, MPI_Info *newinfo) ROMIO_API_PUBLIC;
|
||||
int MPI_Info_free(MPI_Info *info) ROMIO_API_PUBLIC;
|
||||
|
||||
/* The globus2 device has to rename MPI_ symbols in order to use the vendor
|
||||
MPI as one of its transport mechanisms. Therefore, the following undefines
|
||||
@@ -329,8 +345,8 @@ int MPI_Info_free(MPI_Info *info);
|
||||
#endif
|
||||
#endif
|
||||
/* above needed for some versions of mpi.h in MPICH!! */
|
||||
MPI_Fint MPI_Info_c2f(MPI_Info info);
|
||||
MPI_Info MPI_Info_f2c(MPI_Fint info);
|
||||
MPI_Fint MPI_Info_c2f(MPI_Info info) ROMIO_API_PUBLIC;
|
||||
MPI_Info MPI_Info_f2c(MPI_Fint info) ROMIO_API_PUBLIC;
|
||||
#endif
|
||||
|
||||
#endif /* HAVE_PRAGMA_HP_SEC_DEF */
|
||||
@@ -340,36 +356,36 @@ MPI_Info MPI_Info_f2c(MPI_Fint info);
|
||||
|
||||
|
||||
/* Section 9.2 */
|
||||
int PMPI_File_open(MPI_Comm, const char *, int, MPI_Info, MPI_File *);
|
||||
int PMPI_File_close(MPI_File *);
|
||||
int PMPI_File_delete(const char *, MPI_Info);
|
||||
int PMPI_File_set_size(MPI_File, MPI_Offset);
|
||||
int PMPI_File_preallocate(MPI_File, MPI_Offset);
|
||||
int PMPI_File_get_size(MPI_File, MPI_Offset *);
|
||||
int PMPI_File_get_group(MPI_File, MPI_Group *);
|
||||
int PMPI_File_get_amode(MPI_File, int *);
|
||||
int PMPI_File_set_info(MPI_File, MPI_Info);
|
||||
int PMPI_File_get_info(MPI_File, MPI_Info *);
|
||||
int PMPI_File_open(MPI_Comm, const char *, int, MPI_Info, MPI_File *) ROMIO_API_PUBLIC;
|
||||
int PMPI_File_close(MPI_File *) ROMIO_API_PUBLIC;
|
||||
int PMPI_File_delete(const char *, MPI_Info) ROMIO_API_PUBLIC;
|
||||
int PMPI_File_set_size(MPI_File, MPI_Offset) ROMIO_API_PUBLIC;
|
||||
int PMPI_File_preallocate(MPI_File, MPI_Offset) ROMIO_API_PUBLIC;
|
||||
int PMPI_File_get_size(MPI_File, MPI_Offset *) ROMIO_API_PUBLIC;
|
||||
int PMPI_File_get_group(MPI_File, MPI_Group *) ROMIO_API_PUBLIC;
|
||||
int PMPI_File_get_amode(MPI_File, int *) ROMIO_API_PUBLIC;
|
||||
int PMPI_File_set_info(MPI_File, MPI_Info) ROMIO_API_PUBLIC;
|
||||
int PMPI_File_get_info(MPI_File, MPI_Info *) ROMIO_API_PUBLIC;
|
||||
|
||||
/* Section 9.3 */
|
||||
int PMPI_File_set_view(MPI_File, MPI_Offset,
|
||||
MPI_Datatype, MPI_Datatype, const char *, MPI_Info);
|
||||
MPI_Datatype, MPI_Datatype, const char *, MPI_Info) ROMIO_API_PUBLIC;
|
||||
int PMPI_File_get_view(MPI_File, MPI_Offset *,
|
||||
MPI_Datatype *, MPI_Datatype *, char *);
|
||||
MPI_Datatype *, MPI_Datatype *, char *) ROMIO_API_PUBLIC;
|
||||
|
||||
/* Section 9.4.2 */
|
||||
int PMPI_File_read_at(MPI_File, MPI_Offset, void *,
|
||||
int, MPI_Datatype, MPI_Status *)
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(3,5);
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(3,5) ROMIO_API_PUBLIC;
|
||||
int PMPI_File_read_at_all(MPI_File, MPI_Offset, void *,
|
||||
int, MPI_Datatype, MPI_Status *)
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(3,5);
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(3,5) ROMIO_API_PUBLIC;
|
||||
int PMPI_File_write_at(MPI_File, MPI_Offset, const void *,
|
||||
int, MPI_Datatype, MPI_Status *)
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(3,5);
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(3,5) ROMIO_API_PUBLIC;
|
||||
int PMPI_File_write_at_all(MPI_File, MPI_Offset, const void *,
|
||||
int, MPI_Datatype, MPI_Status *)
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(3,5);
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(3,5) ROMIO_API_PUBLIC;
|
||||
|
||||
/* nonblocking calls currently use MPIO_Request, because generalized
|
||||
requests not yet implemented. For the same reason, MPIO_Test and
|
||||
@@ -377,155 +393,155 @@ int PMPI_File_write_at_all(MPI_File, MPI_Offset, const void *,
|
||||
|
||||
int PMPI_File_iread_at(MPI_File, MPI_Offset, void *,
|
||||
int, MPI_Datatype, MPIO_Request *)
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(3,5);
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(3,5) ROMIO_API_PUBLIC;
|
||||
int PMPI_File_iwrite_at(MPI_File, MPI_Offset, const void *,
|
||||
int, MPI_Datatype, MPIO_Request *)
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(3,5);
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(3,5) ROMIO_API_PUBLIC;
|
||||
|
||||
/* Section 9.4.3 */
|
||||
int PMPI_File_read(MPI_File, void *, int, MPI_Datatype, MPI_Status *)
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(2,4);
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(2,4) ROMIO_API_PUBLIC;
|
||||
int PMPI_File_read_all(MPI_File, void *, int, MPI_Datatype, MPI_Status *)
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(2,4);
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(2,4) ROMIO_API_PUBLIC;
|
||||
int PMPI_File_write(MPI_File, const void *, int, MPI_Datatype, MPI_Status *)
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(2,4);
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(2,4) ROMIO_API_PUBLIC;
|
||||
int PMPI_File_write_all(MPI_File, const void *, int, MPI_Datatype, MPI_Status *)
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(2,4);
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(2,4) ROMIO_API_PUBLIC;
|
||||
|
||||
/* nonblocking calls currently use MPIO_Request, because generalized
|
||||
requests not yet implemented. For the same reason, MPIO_Test and
|
||||
MPIO_Wait are used to test and wait on nonblocking I/O requests */
|
||||
|
||||
int PMPI_File_iread(MPI_File, void *, int, MPI_Datatype, MPIO_Request *)
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(2,4);
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(2,4) ROMIO_API_PUBLIC;
|
||||
int PMPI_File_iwrite(MPI_File, const void *, int, MPI_Datatype, MPIO_Request *)
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(2,4);
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(2,4) ROMIO_API_PUBLIC;
|
||||
|
||||
int PMPI_File_seek(MPI_File, MPI_Offset, int);
|
||||
int PMPI_File_get_position(MPI_File, MPI_Offset *);
|
||||
int PMPI_File_get_byte_offset(MPI_File, MPI_Offset, MPI_Offset *);
|
||||
int PMPI_File_seek(MPI_File, MPI_Offset, int) ROMIO_API_PUBLIC;
|
||||
int PMPI_File_get_position(MPI_File, MPI_Offset *) ROMIO_API_PUBLIC;
|
||||
int PMPI_File_get_byte_offset(MPI_File, MPI_Offset, MPI_Offset *) ROMIO_API_PUBLIC;
|
||||
|
||||
/* Section 9.4.4 */
|
||||
int PMPI_File_read_shared(MPI_File, void *, int, MPI_Datatype, MPI_Status *)
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(2,4);
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(2,4) ROMIO_API_PUBLIC;
|
||||
int PMPI_File_write_shared(MPI_File, const void *, int, MPI_Datatype, MPI_Status *)
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(2,4);
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(2,4) ROMIO_API_PUBLIC;
|
||||
int PMPI_File_iread_shared(MPI_File, void *, int,
|
||||
MPI_Datatype, MPIO_Request *)
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(2,4);
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(2,4) ROMIO_API_PUBLIC;
|
||||
int PMPI_File_iwrite_shared(MPI_File, const void *, int,
|
||||
MPI_Datatype, MPIO_Request *)
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(2,4);
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(2,4) ROMIO_API_PUBLIC;
|
||||
int PMPI_File_read_ordered(MPI_File, void *, int, MPI_Datatype, MPI_Status *)
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(2,4);
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(2,4) ROMIO_API_PUBLIC;
|
||||
int PMPI_File_write_ordered(MPI_File, const void *, int, MPI_Datatype, MPI_Status *)
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(2,4);
|
||||
int PMPI_File_seek_shared(MPI_File, MPI_Offset, int);
|
||||
int PMPI_File_get_position_shared(MPI_File, MPI_Offset *);
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(2,4) ROMIO_API_PUBLIC;
|
||||
int PMPI_File_seek_shared(MPI_File, MPI_Offset, int) ROMIO_API_PUBLIC;
|
||||
int PMPI_File_get_position_shared(MPI_File, MPI_Offset *) ROMIO_API_PUBLIC;
|
||||
|
||||
/* Section 9.4.5 */
|
||||
int PMPI_File_read_at_all_begin(MPI_File, MPI_Offset, void *,
|
||||
int, MPI_Datatype)
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(3,5);
|
||||
int PMPI_File_read_at_all_end(MPI_File, void *, MPI_Status *);
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(3,5) ROMIO_API_PUBLIC;
|
||||
int PMPI_File_read_at_all_end(MPI_File, void *, MPI_Status *) ROMIO_API_PUBLIC;
|
||||
int PMPI_File_write_at_all_begin(MPI_File, MPI_Offset, const void *,
|
||||
int, MPI_Datatype)
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(3,5);
|
||||
int PMPI_File_write_at_all_end(MPI_File, const void *, MPI_Status *);
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(3,5) ROMIO_API_PUBLIC;
|
||||
int PMPI_File_write_at_all_end(MPI_File, const void *, MPI_Status *) ROMIO_API_PUBLIC;
|
||||
int PMPI_File_read_all_begin(MPI_File, void *, int, MPI_Datatype)
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(2,4);
|
||||
int PMPI_File_read_all_end(MPI_File, void *, MPI_Status *);
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(2,4) ROMIO_API_PUBLIC;
|
||||
int PMPI_File_read_all_end(MPI_File, void *, MPI_Status *) ROMIO_API_PUBLIC;
|
||||
int PMPI_File_write_all_begin(MPI_File, const void *, int, MPI_Datatype)
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(2,4);
|
||||
int PMPI_File_write_all_end(MPI_File, const void *, MPI_Status *);
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(2,4) ROMIO_API_PUBLIC;
|
||||
int PMPI_File_write_all_end(MPI_File, const void *, MPI_Status *) ROMIO_API_PUBLIC;
|
||||
int PMPI_File_read_ordered_begin(MPI_File, void *, int, MPI_Datatype)
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(2,4);
|
||||
int PMPI_File_read_ordered_end(MPI_File, void *, MPI_Status *);
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(2,4) ROMIO_API_PUBLIC;
|
||||
int PMPI_File_read_ordered_end(MPI_File, void *, MPI_Status *) ROMIO_API_PUBLIC;
|
||||
int PMPI_File_write_ordered_begin(MPI_File, const void *, int, MPI_Datatype)
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(2,4);
|
||||
int PMPI_File_write_ordered_end(MPI_File, const void *, MPI_Status *);
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(2,4) ROMIO_API_PUBLIC;
|
||||
int PMPI_File_write_ordered_end(MPI_File, const void *, MPI_Status *) ROMIO_API_PUBLIC;
|
||||
|
||||
/* Section 9.5.1 */
|
||||
int PMPI_File_get_type_extent(MPI_File, MPI_Datatype, MPI_Aint *);
|
||||
int PMPI_File_get_type_extent(MPI_File, MPI_Datatype, MPI_Aint *) ROMIO_API_PUBLIC;
|
||||
|
||||
/* Section 9.5.3 */
|
||||
int PMPI_Register_datarep(const char *,
|
||||
MPI_Datarep_conversion_function *,
|
||||
MPI_Datarep_conversion_function *,
|
||||
MPI_Datarep_extent_function *,
|
||||
void *);
|
||||
void *) ROMIO_API_PUBLIC;
|
||||
|
||||
/* Section 9.6.1 */
|
||||
int PMPI_File_set_atomicity(MPI_File, int);
|
||||
int PMPI_File_get_atomicity(MPI_File, int *);
|
||||
int PMPI_File_sync(MPI_File);
|
||||
int PMPI_File_set_atomicity(MPI_File, int) ROMIO_API_PUBLIC;
|
||||
int PMPI_File_get_atomicity(MPI_File, int *) ROMIO_API_PUBLIC;
|
||||
int PMPI_File_sync(MPI_File) ROMIO_API_PUBLIC;
|
||||
|
||||
/* Section 4.13.3 */
|
||||
#ifndef MPICH
|
||||
/* MPICH provides these definitions */
|
||||
int PMPI_File_set_errhandler( MPI_File, MPI_Errhandler );
|
||||
int PMPI_File_get_errhandler( MPI_File, MPI_Errhandler * );
|
||||
int PMPI_File_set_errhandler( MPI_File, MPI_Errhandler ) ROMIO_API_PUBLIC;
|
||||
int PMPI_File_get_errhandler( MPI_File, MPI_Errhandler * ) ROMIO_API_PUBLIC;
|
||||
#endif
|
||||
|
||||
/* For MPI 3.1 */
|
||||
int PMPI_File_iread_at_all(MPI_File fh, MPI_Offset offset, void *buf, int count,
|
||||
MPI_Datatype datatype, MPI_Request *request)
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(3,5);
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(3,5) ROMIO_API_PUBLIC;
|
||||
int PMPI_File_iwrite_at_all(MPI_File fh, MPI_Offset offset, const void *buf, int count,
|
||||
MPI_Datatype datatype, MPI_Request *request)
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(3,5);
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(3,5) ROMIO_API_PUBLIC;
|
||||
int PMPI_File_iread_all(MPI_File fh, void *buf, int count, MPI_Datatype datatype,
|
||||
MPI_Request *request)
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(2,4);
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(2,4) ROMIO_API_PUBLIC;
|
||||
int PMPI_File_iwrite_all(MPI_File fh, const void *buf, int count, MPI_Datatype datatype,
|
||||
MPI_Request *request)
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(2,4);
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(2,4) ROMIO_API_PUBLIC;
|
||||
|
||||
#ifndef HAVE_MPI_DARRAY_SUBARRAY
|
||||
/* Section 4.14.4 */
|
||||
int PMPI_Type_create_subarray(int, int *, int *, int *, int,
|
||||
MPI_Datatype, MPI_Datatype *);
|
||||
MPI_Datatype, MPI_Datatype *) ROMIO_API_PUBLIC;
|
||||
|
||||
/* Section 4.14.5 */
|
||||
int PMPI_Type_create_darray(int, int, int, int *, int *,
|
||||
int *, int *, int, MPI_Datatype, MPI_Datatype *);
|
||||
int *, int *, int, MPI_Datatype, MPI_Datatype *) ROMIO_API_PUBLIC;
|
||||
#endif
|
||||
|
||||
/* Section 4.12.4 */
|
||||
MPI_File PMPI_File_f2c(MPI_Fint);
|
||||
MPI_Fint PMPI_File_c2f(MPI_File);
|
||||
MPI_File PMPI_File_f2c(MPI_Fint) ROMIO_API_PUBLIC;
|
||||
MPI_Fint PMPI_File_c2f(MPI_File) ROMIO_API_PUBLIC;
|
||||
|
||||
#ifndef HAVE_MPI_GREQUEST
|
||||
/* The following functions are required if generalized requests are not
|
||||
available, because in that case, an MPIO_Request object
|
||||
is currently used for nonblocking I/O. */
|
||||
int PMPIO_Test(MPIO_Request *, int *, MPI_Status *);
|
||||
int PMPIO_Wait(MPIO_Request *, MPI_Status *);
|
||||
int PMPIO_Testall(int, MPIO_Request *, int *, MPI_Status *);
|
||||
int PMPIO_Waitall(int, MPIO_Request *, MPI_Status *);
|
||||
int PMPIO_Testany(int, MPIO_Request *, int *, int *, MPI_Status *);
|
||||
int PMPIO_Waitany(int, MPIO_Request *, int *, MPI_Status *);
|
||||
int PMPIO_Waitsome(int, MPIO_Request *, int *, int *, MPI_Status *);
|
||||
int PMPIO_Testsome(int, MPIO_Request *, int *, int *, MPI_Status *);
|
||||
MPI_Fint PMPIO_Request_c2f(MPIO_Request);
|
||||
MPIO_Request PMPIO_Request_f2c(MPI_Fint);
|
||||
int PMPIO_Test(MPIO_Request *, int *, MPI_Status *) ROMIO_API_PUBLIC;
|
||||
int PMPIO_Wait(MPIO_Request *, MPI_Status *) ROMIO_API_PUBLIC;
|
||||
int PMPIO_Testall(int, MPIO_Request *, int *, MPI_Status *) ROMIO_API_PUBLIC;
|
||||
int PMPIO_Waitall(int, MPIO_Request *, MPI_Status *) ROMIO_API_PUBLIC;
|
||||
int PMPIO_Testany(int, MPIO_Request *, int *, int *, MPI_Status *) ROMIO_API_PUBLIC;
|
||||
int PMPIO_Waitany(int, MPIO_Request *, int *, MPI_Status *) ROMIO_API_PUBLIC;
|
||||
int PMPIO_Waitsome(int, MPIO_Request *, int *, int *, MPI_Status *) ROMIO_API_PUBLIC;
|
||||
int PMPIO_Testsome(int, MPIO_Request *, int *, int *, MPI_Status *) ROMIO_API_PUBLIC;
|
||||
MPI_Fint PMPIO_Request_c2f(MPIO_Request) ROMIO_API_PUBLIC;
|
||||
MPIO_Request PMPIO_Request_f2c(MPI_Fint) ROMIO_API_PUBLIC;
|
||||
#endif /* HAVE_MPI_GREQUEST */
|
||||
|
||||
/* info functions if not defined in the MPI implementation */
|
||||
#ifndef HAVE_MPI_INFO
|
||||
|
||||
int PMPI_Info_create(MPI_Info *);
|
||||
int PMPI_Info_set(MPI_Info, char *, char *);
|
||||
int PMPI_Info_delete(MPI_Info, char *);
|
||||
int PMPI_Info_get(MPI_Info, char *, int, char *, int *);
|
||||
int PMPI_Info_get_valuelen(MPI_Info, char *, int *, int *);
|
||||
int PMPI_Info_get_nkeys(MPI_Info, int *);
|
||||
int PMPI_Info_get_nthkey(MPI_Info, int, char *);
|
||||
int PMPI_Info_dup(MPI_Info, MPI_Info *);
|
||||
int PMPI_Info_free(MPI_Info *);
|
||||
int PMPI_Info_create(MPI_Info *) ROMIO_API_PUBLIC;
|
||||
int PMPI_Info_set(MPI_Info, char *, char *) ROMIO_API_PUBLIC;
|
||||
int PMPI_Info_delete(MPI_Info, char *) ROMIO_API_PUBLIC;
|
||||
int PMPI_Info_get(MPI_Info, char *, int, char *, int *) ROMIO_API_PUBLIC;
|
||||
int PMPI_Info_get_valuelen(MPI_Info, char *, int *, int *) ROMIO_API_PUBLIC;
|
||||
int PMPI_Info_get_nkeys(MPI_Info, int *) ROMIO_API_PUBLIC;
|
||||
int PMPI_Info_get_nthkey(MPI_Info, int, char *) ROMIO_API_PUBLIC;
|
||||
int PMPI_Info_dup(MPI_Info, MPI_Info *) ROMIO_API_PUBLIC;
|
||||
int PMPI_Info_free(MPI_Info *) ROMIO_API_PUBLIC;
|
||||
|
||||
MPI_Fint PMPI_Info_c2f(MPI_Info);
|
||||
MPI_Info PMPI_Info_f2c(MPI_Fint);
|
||||
MPI_Fint PMPI_Info_c2f(MPI_Info) ROMIO_API_PUBLIC;
|
||||
MPI_Info PMPI_Info_f2c(MPI_Fint) ROMIO_API_PUBLIC;
|
||||
#endif
|
||||
|
||||
#if defined(__cplusplus)
|
||||
|
||||
@@ -1,241 +0,0 @@
|
||||
#ifndef _SRC_OPA_CONFIG_H
|
||||
#define _SRC_OPA_CONFIG_H 1
|
||||
|
||||
/* src/opa_config.h. Generated automatically at end of configure. */
|
||||
/* src/config.h. Generated from config.h.in by configure. */
|
||||
/* src/config.h.in. Generated from configure.ac by autoheader. */
|
||||
|
||||
/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */
|
||||
/*
|
||||
* (C) 2008 by Argonne National Laboratory.
|
||||
* See COPYRIGHT in top-level directory.
|
||||
*/
|
||||
|
||||
|
||||
/* define if lock-based emulation was explicitly requested at configure time
|
||||
via --with-atomic-primitives=no */
|
||||
/* #undef EXPLICIT_EMULATION */
|
||||
|
||||
/* Define to 1 if you have the <atomic.h> header file. */
|
||||
/* #undef HAVE_ATOMIC_H */
|
||||
|
||||
/* Define to 1 if you have the <dlfcn.h> header file. */
|
||||
#ifndef OPA_HAVE_DLFCN_H
|
||||
#define OPA_HAVE_DLFCN_H 1
|
||||
#endif
|
||||
|
||||
/* define to 1 if we have support for gcc ARM atomics */
|
||||
/* #undef HAVE_GCC_AND_ARM_ASM */
|
||||
|
||||
/* define to 1 if we have support for gcc ia64 primitives */
|
||||
/* #undef HAVE_GCC_AND_IA64_ASM */
|
||||
|
||||
/* define to 1 if we have support for gcc PowerPC atomics */
|
||||
/* #undef HAVE_GCC_AND_POWERPC_ASM */
|
||||
|
||||
/* define to 1 if we have support for gcc SiCortex atomics */
|
||||
/* #undef HAVE_GCC_AND_SICORTEX_ASM */
|
||||
|
||||
/* Define if GNU __attribute__ is supported */
|
||||
#ifndef OPA_HAVE_GCC_ATTRIBUTE
|
||||
#define OPA_HAVE_GCC_ATTRIBUTE 1
|
||||
#endif
|
||||
|
||||
/* define to 1 if we have support for gcc atomic intrinsics */
|
||||
#ifndef OPA_HAVE_GCC_INTRINSIC_ATOMICS
|
||||
#define OPA_HAVE_GCC_INTRINSIC_ATOMICS 1
|
||||
#endif
|
||||
|
||||
/* define to 1 if we have support for gcc x86/x86_64 primitives */
|
||||
#ifndef OPA_HAVE_GCC_X86_32_64
|
||||
#define OPA_HAVE_GCC_X86_32_64 1
|
||||
#endif
|
||||
|
||||
/* define to 1 if we have support for gcc x86 primitives for pre-Pentium 4 */
|
||||
#ifndef OPA_HAVE_GCC_X86_32_64_P3
|
||||
#define OPA_HAVE_GCC_X86_32_64_P3 1
|
||||
#endif
|
||||
|
||||
/* Define to 1 if you have the <intrin.h> header file. */
|
||||
/* #undef HAVE_INTRIN_H */
|
||||
|
||||
/* Define to 1 if you have the <inttypes.h> header file. */
|
||||
#ifndef OPA_HAVE_INTTYPES_H
|
||||
#define OPA_HAVE_INTTYPES_H 1
|
||||
#endif
|
||||
|
||||
/* Define to 1 if you have the `pthread' library (-lpthread). */
|
||||
#ifndef OPA_HAVE_LIBPTHREAD
|
||||
#define OPA_HAVE_LIBPTHREAD 1
|
||||
#endif
|
||||
|
||||
/* Define to 1 if you have the <memory.h> header file. */
|
||||
#ifndef OPA_HAVE_MEMORY_H
|
||||
#define OPA_HAVE_MEMORY_H 1
|
||||
#endif
|
||||
|
||||
/* define to 1 if we have support for Windows NT atomic intrinsics */
|
||||
/* #undef HAVE_NT_INTRINSICS */
|
||||
|
||||
/* Define to 1 if you have the <pthread.h> header file. */
|
||||
#ifndef OPA_HAVE_PTHREAD_H
|
||||
#define OPA_HAVE_PTHREAD_H 1
|
||||
#endif
|
||||
|
||||
/* Define to 1 if you have the `pthread_yield' function. */
|
||||
#ifndef OPA_HAVE_PTHREAD_YIELD
|
||||
#define OPA_HAVE_PTHREAD_YIELD 1
|
||||
#endif
|
||||
|
||||
/* Define to 1 if you have the `sched_yield' function. */
|
||||
/* #undef HAVE_SCHED_YIELD */
|
||||
|
||||
/* Define to 1 if you have the <stddef.h> header file. */
|
||||
#ifndef OPA_HAVE_STDDEF_H
|
||||
#define OPA_HAVE_STDDEF_H 1
|
||||
#endif
|
||||
|
||||
/* Define to 1 if you have the <stdint.h> header file. */
|
||||
#ifndef OPA_HAVE_STDINT_H
|
||||
#define OPA_HAVE_STDINT_H 1
|
||||
#endif
|
||||
|
||||
/* Define to 1 if you have the <stdlib.h> header file. */
|
||||
#ifndef OPA_HAVE_STDLIB_H
|
||||
#define OPA_HAVE_STDLIB_H 1
|
||||
#endif
|
||||
|
||||
/* Define if strict checking of atomic operation fairness is desired */
|
||||
/* #undef HAVE_STRICT_FAIRNESS_CHECKS */
|
||||
|
||||
/* Define to 1 if you have the <strings.h> header file. */
|
||||
#ifndef OPA_HAVE_STRINGS_H
|
||||
#define OPA_HAVE_STRINGS_H 1
|
||||
#endif
|
||||
|
||||
/* Define to 1 if you have the <string.h> header file. */
|
||||
#ifndef OPA_HAVE_STRING_H
|
||||
#define OPA_HAVE_STRING_H 1
|
||||
#endif
|
||||
|
||||
/* define to 1 if we have support for Sun atomic operations library */
|
||||
/* #undef HAVE_SUN_ATOMIC_OPS */
|
||||
|
||||
/* Define to 1 if you have the <sys/stat.h> header file. */
|
||||
#ifndef OPA_HAVE_SYS_STAT_H
|
||||
#define OPA_HAVE_SYS_STAT_H 1
|
||||
#endif
|
||||
|
||||
/* Define to 1 if you have the <sys/types.h> header file. */
|
||||
#ifndef OPA_HAVE_SYS_TYPES_H
|
||||
#define OPA_HAVE_SYS_TYPES_H 1
|
||||
#endif
|
||||
|
||||
/* Define to 1 if you have the <unistd.h> header file. */
|
||||
#ifndef OPA_HAVE_UNISTD_H
|
||||
#define OPA_HAVE_UNISTD_H 1
|
||||
#endif
|
||||
|
||||
/* Define to the sub-directory where libtool stores uninstalled libraries. */
|
||||
#ifndef OPA_LT_OBJDIR
|
||||
#define OPA_LT_OBJDIR ".libs/"
|
||||
#endif
|
||||
|
||||
/* define to the maximum number of simultaneous threads */
|
||||
#ifndef OPA_MAX_NTHREADS
|
||||
#define OPA_MAX_NTHREADS 100
|
||||
#endif
|
||||
|
||||
/* Define to 1 if assertions should be disabled. */
|
||||
/* #undef NDEBUG */
|
||||
|
||||
/* Name of package */
|
||||
#ifndef OPA_PACKAGE
|
||||
#define OPA_PACKAGE "openpa"
|
||||
#endif
|
||||
|
||||
/* Define to the address where bug reports for this package should be sent. */
|
||||
#ifndef OPA_PACKAGE_BUGREPORT
|
||||
#define OPA_PACKAGE_BUGREPORT "https://trac.mcs.anl.gov/projects/openpa/newticket"
|
||||
#endif
|
||||
|
||||
/* Define to the full name of this package. */
|
||||
#ifndef OPA_PACKAGE_NAME
|
||||
#define OPA_PACKAGE_NAME "OpenPA"
|
||||
#endif
|
||||
|
||||
/* Define to the full name and version of this package. */
|
||||
#ifndef OPA_PACKAGE_STRING
|
||||
#define OPA_PACKAGE_STRING "OpenPA 1.0.3"
|
||||
#endif
|
||||
|
||||
/* Define to the one symbol short name of this package. */
|
||||
#ifndef OPA_PACKAGE_TARNAME
|
||||
#define OPA_PACKAGE_TARNAME "openpa"
|
||||
#endif
|
||||
|
||||
/* Define to the home page for this package. */
|
||||
#ifndef OPA_PACKAGE_URL
|
||||
#define OPA_PACKAGE_URL ""
|
||||
#endif
|
||||
|
||||
/* Define to the version of this package. */
|
||||
#ifndef OPA_PACKAGE_VERSION
|
||||
#define OPA_PACKAGE_VERSION "1.0.3"
|
||||
#endif
|
||||
|
||||
/* The size of `int', as computed by sizeof. */
|
||||
#ifndef OPA_SIZEOF_INT
|
||||
#define OPA_SIZEOF_INT 4
|
||||
#endif
|
||||
|
||||
/* The size of `void *', as computed by sizeof. */
|
||||
#ifndef OPA_SIZEOF_VOID_P
|
||||
#define OPA_SIZEOF_VOID_P 8
|
||||
#endif
|
||||
|
||||
/* Define to 1 if you have the ANSI C header files. */
|
||||
#ifndef OPA_STDC_HEADERS
|
||||
#define OPA_STDC_HEADERS 1
|
||||
#endif
|
||||
|
||||
/* define to 1 to force using lock-based atomic primitives */
|
||||
/* #undef USE_LOCK_BASED_PRIMITIVES */
|
||||
|
||||
/* define to 1 if unsafe (non-atomic) primitives should be used */
|
||||
/* #undef USE_UNSAFE_PRIMITIVES */
|
||||
|
||||
/* Version number of package */
|
||||
#ifndef OPA_VERSION
|
||||
#define OPA_VERSION "1.0.3"
|
||||
#endif
|
||||
|
||||
/* Define to empty if `const' does not conform to ANSI C. */
|
||||
/* #undef const */
|
||||
|
||||
/* Define to `__inline__' or `__inline' if that's what the C compiler
|
||||
calls it, or to nothing if 'inline' is not supported under any name. */
|
||||
#ifndef __cplusplus
|
||||
/* #undef inline */
|
||||
#endif
|
||||
|
||||
/* Define to the equivalent of the C99 'restrict' keyword, or to
|
||||
nothing if this is not supported. Do not define if restrict is
|
||||
supported directly. */
|
||||
#ifndef _opa_restrict
|
||||
#define _opa_restrict __restrict
|
||||
#endif
|
||||
/* Work around a bug in Sun C++: it does not support _Restrict or
|
||||
__restrict__, even though the corresponding Sun C compiler ends up with
|
||||
"#define restrict _Restrict" or "#define restrict __restrict__" in the
|
||||
previous line. Perhaps some future version of Sun C++ will work with
|
||||
restrict; if so, hopefully it defines __RESTRICT like Sun C does. */
|
||||
#if defined __SUNPRO_CC && !defined __RESTRICT
|
||||
# define _Restrict
|
||||
# define __restrict__
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
/* once: _SRC_OPA_CONFIG_H */
|
||||
#endif
|
||||
@@ -1,160 +0,0 @@
|
||||
/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */
|
||||
/*
|
||||
* (C) 2008 by Argonne National Laboratory.
|
||||
* See COPYRIGHT in top-level directory.
|
||||
*/
|
||||
|
||||
#ifndef OPA_PRIMITIVES_H_INCLUDED
|
||||
#define OPA_PRIMITIVES_H_INCLUDED
|
||||
|
||||
#include "opa_config.h"
|
||||
#include "opa_util.h"
|
||||
|
||||
/* Clean up some of the opa_config.h definitions. This is a consequence
|
||||
of using the AX_PREFIX_CONFIG_H macro. Autoconf won't define inline
|
||||
or _opa_inline when a real "inline" works. Since we are
|
||||
unconditionally using _opa_inline we must define it ourselves in this
|
||||
case. */
|
||||
#ifndef _opa_inline
|
||||
#define _opa_inline inline
|
||||
#endif
|
||||
#ifndef _opa_restrict
|
||||
#define _opa_restrict restrict
|
||||
#endif
|
||||
#ifndef _opa_const
|
||||
#define _opa_const const
|
||||
#endif
|
||||
|
||||
/*
|
||||
Primitive atomic functions
|
||||
--------------------------
|
||||
|
||||
The included file is responsible for defining the types of OPA_int_t and
|
||||
OPA_ptr_t as well as a set of functions for operating on these
|
||||
types. If you have the following declaration:
|
||||
|
||||
OPA_int_t atomic_var;
|
||||
|
||||
Then in order for the emulation functions to compile, the underlying value of
|
||||
atomic_var should be accessible via:
|
||||
|
||||
atomic_var.v;
|
||||
|
||||
The same goes for OPA_ptr_t.
|
||||
|
||||
The atomic functions that must be ported for each architecture:
|
||||
|
||||
static _opa_inline int OPA_load_int(_opa_const OPA_int_t *ptr);
|
||||
static _opa_inline void OPA_store_int(OPA_int_t *ptr, int val);
|
||||
static _opa_inline void *OPA_load_ptr(_opa_const OPA_ptr_t *ptr);
|
||||
static _opa_inline void OPA_store_ptr(OPA_ptr_t *ptr, void *val);
|
||||
|
||||
static _opa_inline void OPA_add_int(OPA_int_t *ptr, int val);
|
||||
static _opa_inline void OPA_incr_int(OPA_int_t *ptr);
|
||||
static _opa_inline void OPA_decr_int(OPA_int_t *ptr);
|
||||
|
||||
static _opa_inline int OPA_decr_and_test_int(OPA_int_t *ptr);
|
||||
static _opa_inline int OPA_fetch_and_add_int(OPA_int_t *ptr, int val);
|
||||
static _opa_inline int OPA_fetch_and_incr_int(OPA_int_t *ptr);
|
||||
static _opa_inline int OPA_fetch_and_decr_int(OPA_int_t *ptr);
|
||||
|
||||
static _opa_inline void *OPA_cas_ptr(OPA_ptr_t *ptr, void *oldv, void *newv);
|
||||
static _opa_inline int OPA_cas_int(OPA_int_t *ptr, int oldv, int newv);
|
||||
|
||||
static _opa_inline void *OPA_swap_ptr(OPA_ptr_t *ptr, void *val);
|
||||
static _opa_inline int OPA_swap_int(OPA_int_t *ptr, int val);
|
||||
|
||||
// (the memory barriers may be macros instead of inline functions)
|
||||
static _opa_inline void OPA_write_barrier();
|
||||
static _opa_inline void OPA_read_barrier();
|
||||
static _opa_inline void OPA_read_write_barrier();
|
||||
|
||||
// Loads and stores with memory ordering guarantees (also may be macros):
|
||||
static _opa_inline int OPA_load_acquire_int(_opa_const OPA_int_t *ptr);
|
||||
static _opa_inline void OPA_store_release_int(OPA_int_t *ptr, int val);
|
||||
static _opa_inline void *OPA_load_acquire_ptr(_opa_const OPA_ptr_t *ptr);
|
||||
static _opa_inline void OPA_store_release_ptr(OPA_ptr_t *ptr, void *val);
|
||||
|
||||
// Compiler barrier, only preventing compiler reordering, *not* CPU
|
||||
// reordering (may be a macro):
|
||||
static _opa_inline void OPA_compiler_barrier();
|
||||
|
||||
// The following need to be ported only for architectures supporting LL/SC:
|
||||
static _opa_inline int OPA_LL_int(OPA_int_t *ptr);
|
||||
static _opa_inline int OPA_SC_int(OPA_int_t *ptr, int val);
|
||||
static _opa_inline void *OPA_LL_ptr(OPA_ptr_t *ptr);
|
||||
static _opa_inline int OPA_SC_ptr(OPA_ptr_t *ptr, void *val);
|
||||
|
||||
// Additionally, the following initializer macros must be defined:
|
||||
#define OPA_INT_T_INITIALIZER(val_) ...
|
||||
#define OPA_PTR_T_INITIALIZER(val_) ...
|
||||
|
||||
// They should be useable as C89 static initializers like so:
|
||||
|
||||
struct { int x; OPA_int_t y; OPA_ptr_t z; } foo = { 35, OPA_INT_T_INITIALIZER(1), OPA_PTR_T_INITIALIZER(NULL) };
|
||||
*/
|
||||
|
||||
/* Include the appropriate header for the architecture */
|
||||
#if defined(OPA_USE_UNSAFE_PRIMITIVES)
|
||||
/* comes first to permit user overrides in the style of NDEBUG */
|
||||
#include "primitives/opa_unsafe.h"
|
||||
#elif defined(OPA_HAVE_GCC_AND_POWERPC_ASM)
|
||||
#include "primitives/opa_gcc_ppc.h"
|
||||
#elif defined(OPA_HAVE_GCC_AND_ARM_ASM)
|
||||
#include "primitives/opa_gcc_arm.h"
|
||||
#elif defined(OPA_HAVE_GCC_X86_32_64)
|
||||
#include "primitives/opa_gcc_intel_32_64.h"
|
||||
#elif defined(OPA_HAVE_GCC_X86_32_64_P3)
|
||||
#include "primitives/opa_gcc_intel_32_64_p3.h"
|
||||
#elif defined(OPA_HAVE_GCC_AND_IA64_ASM)
|
||||
#include "primitives/opa_gcc_ia64.h"
|
||||
#elif defined(OPA_HAVE_GCC_AND_SICORTEX_ASM)
|
||||
#include "primitives/opa_gcc_sicortex.h"
|
||||
#elif defined(OPA_HAVE_GCC_INTRINSIC_ATOMICS)
|
||||
#include "primitives/opa_gcc_intrinsics.h"
|
||||
#elif defined(OPA_HAVE_SUN_ATOMIC_OPS)
|
||||
#include "primitives/opa_sun_atomic_ops.h"
|
||||
#elif defined(OPA_HAVE_NT_INTRINSICS)
|
||||
#include "primitives/opa_nt_intrinsics.h"
|
||||
#elif defined(OPA_USE_LOCK_BASED_PRIMITIVES)
|
||||
#include "primitives/opa_by_lock.h"
|
||||
#else
|
||||
#error no primitives implementation specified
|
||||
#endif
|
||||
|
||||
/*
|
||||
This routine is needed because the MPIU_THREAD_XXX_CS_{ENTER,EXIT} macros do
|
||||
not provide synchronization across multiple processes, only across multiple
|
||||
threads within a process. In order to safely emulate atomic operations on a
|
||||
shared memory region, we need a shared memory backed lock mechanism.
|
||||
|
||||
This routine must be called by any subsystem that intends to use the atomic
|
||||
abstractions if the cpp directive OPA_USE_LOCK_BASED_PRIMITIVES is defined. It must
|
||||
be called exactly once by _all_ processes, not just a single leader. This
|
||||
function will initialize the contents of the lock variable if the caller
|
||||
specifies (isLeader==true). Note that multiple initialization is forbidden
|
||||
by several lock implementations, especially pthreads.
|
||||
|
||||
Inputs:
|
||||
shm_lock - A pointer to an allocated piece of shared memory that can hold
|
||||
a mutex (e.g., pthread_mutex_t). This is not portable to
|
||||
non-pthreads systems at this time.
|
||||
isLeader - This boolean value should be set to true for exactly one
|
||||
thread/process of the group that calls this function.
|
||||
*/
|
||||
#if defined(OPA_HAVE_PTHREAD_H)
|
||||
# include <pthread.h>
|
||||
typedef pthread_mutex_t OPA_emulation_ipl_t;
|
||||
int OPA_Interprocess_lock_init(OPA_emulation_ipl_t *shm_lock, int isLeader);
|
||||
#endif
|
||||
|
||||
|
||||
/* FIXME This should probably be pushed down into the platform-specific headers. */
|
||||
#if defined(OPA_HAVE_SCHED_YIELD)
|
||||
# include <sched.h>
|
||||
# define OPA_busy_wait() sched_yield()
|
||||
#else
|
||||
# define OPA_busy_wait() do { } while (0)
|
||||
#endif
|
||||
|
||||
#endif /* defined(OPA_PRIMITIVES_H_INCLUDED) */
|
||||
@@ -1,286 +0,0 @@
|
||||
/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */
|
||||
/*
|
||||
* (C) 2008 by Argonne National Laboratory.
|
||||
* See COPYRIGHT in top-level directory.
|
||||
*/
|
||||
|
||||
/* Implements a fast, lockfree, multi-producer, single-consumer queue. It's
|
||||
* important to note the *single-consumer* piece of this, since multithreaded
|
||||
* consumption will surely lead to data corruption and/or other problems. */
|
||||
|
||||
#ifndef OPA_QUEUE_H_INCLUDED
|
||||
#define OPA_QUEUE_H_INCLUDED
|
||||
|
||||
#include "opa_primitives.h"
|
||||
#ifdef OPA_HAVE_STDDEF_H
|
||||
#include <stddef.h>
|
||||
#endif /* OPA_HAVE_STDDEF_H */
|
||||
|
||||
/* This value is used to indicate NULL in the OPA_Shm_asymm_base_addr
|
||||
variable. It is non-zero because one of the likely base addresses is zero
|
||||
(indicating memory is actually symmetrically mapped). The value 64 was used
|
||||
because it is unlikely that mmap will choose an address this low for a
|
||||
mapping. */
|
||||
/* XXX DJG TODO put some conditionally compiled error checking in that uses this */
|
||||
#define OPA_SHM_ASYMM_NULL_VAL 64
|
||||
|
||||
extern char *OPA_Shm_asymm_base_addr;
|
||||
|
||||
/* Used to initialize the base address for relative pointers. This interface
|
||||
assumes that there is only one shared memory segment. If this turns out to
|
||||
not be the case in the future, we should probably add support for multiple
|
||||
shm segments.
|
||||
|
||||
This function will return an error if it has already been called. */
|
||||
int OPA_Shm_asymm_init(char *base);
|
||||
|
||||
/* Relative addressing macros. These are for manipulating addresses relative
|
||||
to the start of a shared memory region. */
|
||||
#define OPA_SHM_REL_NULL (0x0)
|
||||
#define OPA_SHM_IS_REL_NULL(rel_ptr) (OPA_load_ptr(&(rel_ptr).offset) == OPA_SHM_REL_NULL)
|
||||
#define OPA_SHM_SET_REL_NULL(rel_ptr) (OPA_store_ptr(&(rel_ptr).offset, OPA_SHM_REL_NULL))
|
||||
#define OPA_SHM_REL_ARE_EQUAL(rel_ptr1, rel_ptr2) \
|
||||
(OPA_load_ptr(&(rel_ptr1).offset) == OPA_load_ptr(&(rel_ptr2).offset))
|
||||
|
||||
/* This structure exists such that it is possible to expand the expressiveness
|
||||
of a relative address at some point in the future. It also provides a
|
||||
modicum of type safety to help prevent certain flavors of errors.
|
||||
|
||||
For example, instead of referencing an offset from a global base address, it
|
||||
might make sense for there to be multiple base addresses. These base
|
||||
addresses could correspond to the start of a segment or region of shared
|
||||
memory. This structure could store the segment number that is used to lookup
|
||||
a base address in a non-shared table. Note that you would have to be very
|
||||
careful about all of this because if you add the segment number as a separate
|
||||
field you can no longer (compare and) swap a relative address atomically. So
|
||||
you'll either have to shave bits from the pointer or make some sort of
|
||||
requirement that relative addresses can only be swapped within the same
|
||||
segment. */
|
||||
typedef struct OPA_Shm_rel_addr_t {
|
||||
OPA_ptr_t offset;
|
||||
} OPA_Shm_rel_addr_t;
|
||||
|
||||
/* converts a relative pointer to an absolute pointer */
|
||||
static _opa_inline
|
||||
void *OPA_Shm_rel_to_abs(OPA_Shm_rel_addr_t r)
|
||||
{
|
||||
void *offset = OPA_load_ptr(&r.offset);
|
||||
OPA_assert((size_t)OPA_Shm_asymm_base_addr != OPA_SHM_ASYMM_NULL_VAL);
|
||||
return (void*)(OPA_Shm_asymm_base_addr + (size_t)offset);
|
||||
}
|
||||
|
||||
/* converts an absolute pointer to a relative pointer */
|
||||
static _opa_inline
|
||||
OPA_Shm_rel_addr_t OPA_Shm_abs_to_rel(void *a)
|
||||
{
|
||||
OPA_Shm_rel_addr_t ret;
|
||||
|
||||
OPA_assert((size_t)OPA_Shm_asymm_base_addr != OPA_SHM_ASYMM_NULL_VAL);
|
||||
OPA_store_ptr(&ret.offset, (void*)((size_t)a - (size_t)OPA_Shm_asymm_base_addr));
|
||||
return ret;
|
||||
}
|
||||
|
||||
static _opa_inline
|
||||
OPA_Shm_rel_addr_t OPA_Shm_swap_rel(OPA_Shm_rel_addr_t *addr, OPA_Shm_rel_addr_t newv) {
|
||||
OPA_Shm_rel_addr_t oldv;
|
||||
OPA_store_ptr(&oldv.offset, OPA_swap_ptr(&addr->offset, OPA_load_ptr(&newv.offset)));
|
||||
return oldv;
|
||||
}
|
||||
|
||||
/* Compare the relative pointer to (relative) null and swap if equal. Prevents
|
||||
the guts of the _rel_addr_t abstraction from bleeding up into the
|
||||
enqueue/dequeue operations. */
|
||||
static _opa_inline
|
||||
OPA_Shm_rel_addr_t OPA_Shm_cas_rel_null(OPA_Shm_rel_addr_t *addr, OPA_Shm_rel_addr_t oldv) {
|
||||
OPA_Shm_rel_addr_t prev;
|
||||
OPA_store_ptr(&prev.offset, OPA_cas_ptr(&(addr->offset), OPA_load_ptr(&oldv.offset), (void*)OPA_SHM_REL_NULL));
|
||||
return prev;
|
||||
}
|
||||
|
||||
/* The shadow head pointer makes this queue implementation perform much better
|
||||
than a standard queue. Unfortunately, it also makes it a bit non-intuitive
|
||||
when read the code. The following is an excerpt from "Design and Evaluation
|
||||
of Nemesis, a Scalable, Low-Latency, Message-Passing Communication
|
||||
Subsystem" by D. Buntinas, G. Mercier, and W. Gropp that gives an
|
||||
explanation:
|
||||
|
||||
A process must access both the head and tail of the queue when it is
|
||||
enqueuing an element on an empty queue or when it is dequeuing an element
|
||||
that is the last element in the queue. In these cases, if the head and
|
||||
tail were in the same cache line, only one L2 cache miss would be
|
||||
encountered. If the queue has more elements in it, however, then the
|
||||
enqueuer only needs to access the tail, and the dequeuer only needs to
|
||||
access the head. If the head and tail were in the same cache line, then
|
||||
there would be L2 misses encountered as a result of false sharing each
|
||||
time a process enqueues an element after another has been dequeued from
|
||||
the same queue, and vice versa. In this case it would be better if the
|
||||
head and tail were in separate cache lines.
|
||||
|
||||
Our solution is to put the head and tail in the same cache line and have a
|
||||
shadow head pointer in a separate cache line. The shadow head is
|
||||
initialized to NULL. The dequeuer uses the shadow head in place of the
|
||||
real head except when the shadow head is NULL, meaning that the queue has
|
||||
become empty. If the shadow head is NULL when the dequeuer tries to
|
||||
dequeue, it checks the value of the real head. If the real head is not
|
||||
NULL, meaning that an element has been enqueued on the queue since the
|
||||
last time the queue became empty, the dequeuer initializes its shadow head
|
||||
to the value of the real head and sets the real head to NULL. In this way,
|
||||
only one L2 cache miss is encountered when enqueuing onto an empty queue
|
||||
or dequeuing from a queue with one element. And because the tail and
|
||||
shadow head are in separate cache lines, there are no L2 cache misses from
|
||||
false sharing.
|
||||
|
||||
We found that using a shadow head pointer reduced one-way latency by about
|
||||
200 ns on a dual 2 GHz Xeon node.
|
||||
*/
|
||||
|
||||
/* Pick an arbitrary cacheline size for now, we can setup a mechanism to detect
|
||||
it at build time later on. This should work well on most intel systems at
|
||||
the very least. */
|
||||
#define OPA_QUEUE_CACHELINE_PADDING 128
|
||||
|
||||
/* All absolute and relative pointers point to the start of the enclosing element. */
|
||||
typedef struct OPA_Queue_info_t {
|
||||
OPA_Shm_rel_addr_t head; /* holds the offset pointer, not the abs ptr */
|
||||
OPA_Shm_rel_addr_t tail; /* holds the offset pointer, not the abs ptr */
|
||||
char padding1[OPA_QUEUE_CACHELINE_PADDING-2*sizeof(OPA_Shm_rel_addr_t)];
|
||||
OPA_Shm_rel_addr_t shadow_head; /* holds the offset pointer, not the abs ptr */
|
||||
char padding2[OPA_QUEUE_CACHELINE_PADDING-sizeof(OPA_Shm_rel_addr_t)];
|
||||
} OPA_Queue_info_t;
|
||||
|
||||
/* Using this header struct even though it's just one element gives us the
|
||||
opportunity to vary the implementation more easily in the future without
|
||||
updating all callers. */
|
||||
typedef struct OPA_Queue_element_hdr_t {
|
||||
OPA_Shm_rel_addr_t next; /* holds the offset pointer, not the abs ptr */
|
||||
} OPA_Queue_element_hdr_t;
|
||||
|
||||
|
||||
/* Used to initialize a queue structure. */
|
||||
void OPA_Queue_init(OPA_Queue_info_t *qhead);
|
||||
|
||||
/* Used to initialize a queue element header. */
|
||||
void OPA_Queue_header_init(OPA_Queue_element_hdr_t *hdr);
|
||||
|
||||
static _opa_inline
|
||||
int OPA_Queue_is_empty(OPA_Queue_info_t *qhead)
|
||||
{
|
||||
int __ret = 0;
|
||||
if (OPA_SHM_IS_REL_NULL (qhead->shadow_head)) {
|
||||
if (OPA_SHM_IS_REL_NULL(qhead->head)) {
|
||||
__ret = 1;
|
||||
}
|
||||
else {
|
||||
qhead->shadow_head = qhead->head;
|
||||
OPA_SHM_SET_REL_NULL(qhead->head); /* reset it for next time */
|
||||
}
|
||||
}
|
||||
return __ret;
|
||||
}
|
||||
|
||||
/* Returns a pointer to the element at the head of the queue. The current
|
||||
implementation of these queue algorithms imposes several notable
|
||||
restrictions on the use of this function:
|
||||
- The caller must currently hold the critical section, just as if you were
|
||||
calling OPA_Queue_dequeue. Failure to do could easily produce incorrect
|
||||
results.
|
||||
- OPA_Queue_is_empty must be called on this queue prior to calling this
|
||||
function. Furthermore, there must be no intervening calls to any
|
||||
OPA_Queue_* functions (for this queue) between _is_empty and _peek_head.
|
||||
Failure to do so will produce incorrect results.
|
||||
|
||||
This operation is effectively the same as the dequeue operation (insofar as
|
||||
it shares the same calling restrictions) but it does not disturb the actual
|
||||
contents of the queue. */
|
||||
static _opa_inline
|
||||
void *OPA_Queue_peek_head(OPA_Queue_info_t *qhead_ptr)
|
||||
{
|
||||
OPA_assert(qhead_ptr != NULL);
|
||||
|
||||
if (OPA_SHM_IS_REL_NULL(qhead_ptr->shadow_head)) {
|
||||
return NULL;
|
||||
}
|
||||
return OPA_Shm_rel_to_abs(qhead_ptr->shadow_head);
|
||||
}
|
||||
|
||||
/* This macro atomically enqueues an element (elt for short) into the queue
|
||||
indicated by qhead_ptr. You need to pass several arguments:
|
||||
qhead_ptr - a pointer to a OPA_Queue_info_t structure to which the
|
||||
element should be enqueued
|
||||
elt_ptr - a pointer to an element structure type that is to be enqueued
|
||||
elt_type - The base type of elt_ptr. That is, if elt_ptr is a
|
||||
'(struct example_t *)' then elt_type is 'struct example_t'.
|
||||
elt_hdr_field - This is the member name of elt_type that is a
|
||||
OPA_Queue_element_hdr_t.
|
||||
|
||||
This queue implementation is loosely modeled after the linked lists used in
|
||||
the linux kernel. You put the list header structure inside of the client
|
||||
structure, rather than the other way around.
|
||||
*/
|
||||
#define OPA_Queue_enqueue(qhead_ptr, elt_ptr, elt_type, elt_hdr_field) \
|
||||
do { \
|
||||
OPA_Shm_rel_addr_t r_prev; \
|
||||
OPA_Shm_rel_addr_t r_elt = OPA_Shm_abs_to_rel(elt_ptr); \
|
||||
\
|
||||
OPA_SHM_SET_REL_NULL((elt_ptr)->elt_hdr_field.next); \
|
||||
\
|
||||
OPA_write_barrier(); \
|
||||
\
|
||||
r_prev = OPA_Shm_swap_rel(&((qhead_ptr)->tail), r_elt); \
|
||||
\
|
||||
if (OPA_SHM_IS_REL_NULL(r_prev)) { \
|
||||
(qhead_ptr)->head = r_elt; \
|
||||
} \
|
||||
else { \
|
||||
elt_type *abs_prev = (elt_type *)OPA_Shm_rel_to_abs(r_prev); \
|
||||
abs_prev->elt_hdr_field.next = r_elt; \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
/* This macro atomically dequeues an element (elt for short) from the queue
|
||||
indicated by qhead_ptr. You need to pass several arguments:
|
||||
qhead_ptr - a pointer to a OPA_Queue_info_t structure to which the
|
||||
element should be dequeued
|
||||
elt_ptr - A pointer to an element structure type that should be populated
|
||||
with the dequeued value. Must be an lvalue.
|
||||
elt_type - The base type of elt_ptr. That is, if elt_ptr is a
|
||||
'(struct example_t *)' then elt_type is 'struct example_t'.
|
||||
elt_hdr_field - This is the member name of elt_type that is a
|
||||
OPA_Queue_element_hdr_t.
|
||||
|
||||
This queue implementation is loosely modeled after the linked lists used in
|
||||
the linux kernel. You put the list header structure inside of the client
|
||||
structure, rather than the other way around.
|
||||
|
||||
NOTE: you must *always* call _is_empty() prior to this function */
|
||||
#define OPA_Queue_dequeue(qhead_ptr, elt_ptr, elt_type, elt_hdr_field) \
|
||||
do { \
|
||||
elt_type *_e; \
|
||||
OPA_Shm_rel_addr_t _r_e; \
|
||||
\
|
||||
_r_e = (qhead_ptr)->shadow_head; \
|
||||
_e = OPA_Shm_rel_to_abs(_r_e); \
|
||||
\
|
||||
if (!OPA_SHM_IS_REL_NULL(_e->elt_hdr_field.next)) { \
|
||||
(qhead_ptr)->shadow_head = _e->elt_hdr_field.next; \
|
||||
} \
|
||||
else { \
|
||||
OPA_Shm_rel_addr_t old_tail; \
|
||||
\
|
||||
OPA_SHM_SET_REL_NULL((qhead_ptr)->shadow_head); \
|
||||
\
|
||||
old_tail = OPA_Shm_cas_rel_null(&((qhead_ptr)->tail), _r_e); \
|
||||
\
|
||||
if (!OPA_SHM_REL_ARE_EQUAL(old_tail, _r_e)) { \
|
||||
while (OPA_SHM_IS_REL_NULL(_e->elt_hdr_field.next)) { \
|
||||
OPA_busy_wait(); \
|
||||
} \
|
||||
(qhead_ptr)->shadow_head = _e->elt_hdr_field.next; \
|
||||
} \
|
||||
} \
|
||||
OPA_SHM_SET_REL_NULL(_e->elt_hdr_field.next); \
|
||||
OPA_read_barrier(); \
|
||||
elt_ptr = _e; \
|
||||
} while (0)
|
||||
|
||||
#endif /* OPA_QUEUE_H_INCLUDED */
|
||||
@@ -1,27 +0,0 @@
|
||||
/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */
|
||||
/*
|
||||
* (C) 2008 by Argonne National Laboratory.
|
||||
* See COPYRIGHT in top-level directory.
|
||||
*/
|
||||
|
||||
#ifndef OPA_UTIL_H_INCLUDED
|
||||
#define OPA_UTIL_H_INCLUDED
|
||||
|
||||
#define OPA_QUOTE(x_) OPA_QUOTE2(x_)
|
||||
#define OPA_QUOTE2(x_) #x_
|
||||
|
||||
#if defined(OPA_HAVE_GCC_ATTRIBUTE)
|
||||
# define OPA_ATTRIBUTE(x_) __attribute__ (x_)
|
||||
#else
|
||||
# define OPA_ATTRIBUTE(x_)
|
||||
#endif
|
||||
|
||||
/* FIXME this just needs a total rework in general with an OPA_NDEBUG or similar. */
|
||||
#define OPA_assert(expr_) do {} while (0)
|
||||
#define OPA_assertp(expr_) do { if (!(expr_)) ++((int *)NULL) } while (0) /* SEGV intentionally */
|
||||
|
||||
/* A compile-time assertion macro. It should cause a compilation error if (expr_) is false. */
|
||||
#define OPA_COMPILE_TIME_ASSERT(expr_) \
|
||||
do { switch(0) { case 0: case (expr_): default: break; } } while (0)
|
||||
|
||||
#endif /* OPA_UTIL_H_INCLUDED */
|
||||
@@ -1,205 +0,0 @@
|
||||
/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */
|
||||
/*
|
||||
* (C) 2008 by Argonne National Laboratory.
|
||||
* See COPYRIGHT in top-level directory.
|
||||
*/
|
||||
|
||||
#ifndef OPA_BY_LOCK_H_INCLUDED
|
||||
#define OPA_BY_LOCK_H_INCLUDED
|
||||
|
||||
/* FIXME For now we rely on pthreads for our IPC locks. This is fairly
|
||||
portable, although it is obviously not 100% portable. Some day when we
|
||||
refactor the OPA_Process_locks code we should be able to use that again. */
|
||||
#if defined(OPA_HAVE_PTHREAD_H)
|
||||
#include <pthread.h>
|
||||
|
||||
/* defined in opa_primitives.c */
|
||||
extern pthread_mutex_t *OPA_emulation_lock;
|
||||
|
||||
/* FIXME these make less sense now that OPA is not inside of MPICH. Is there a
|
||||
simpler name/scheme that could be used here instead? [goodell@ 2009-02-19] */
|
||||
#define OPA_IPC_SINGLE_CS_ENTER(msg) \
|
||||
do { \
|
||||
OPA_assert(OPA_emulation_lock); \
|
||||
pthread_mutex_lock(OPA_emulation_lock); \
|
||||
} while (0)
|
||||
|
||||
#define OPA_IPC_SINGLE_CS_EXIT(msg) \
|
||||
do { \
|
||||
OPA_assert(OPA_emulation_lock); \
|
||||
pthread_mutex_unlock(OPA_emulation_lock); \
|
||||
} while (0)
|
||||
|
||||
typedef struct { volatile int v; } OPA_int_t;
|
||||
typedef struct { int * volatile v; } OPA_ptr_t;
|
||||
|
||||
#define OPA_INT_T_INITIALIZER(val_) { (val_) }
|
||||
#define OPA_PTR_T_INITIALIZER(val_) { (val_) }
|
||||
|
||||
/*
|
||||
Emulated atomic primitives
|
||||
--------------------------
|
||||
|
||||
These are versions of the atomic primitives that emulate the proper behavior
|
||||
via the use of an inter-process lock. For more information on their
|
||||
individual behavior, please see the comment on the corresponding top level
|
||||
function.
|
||||
|
||||
In general, these emulated primitives should _not_ be used. Most algorithms
|
||||
can be more efficiently implemented by putting most or all of the algorithm
|
||||
inside of a single critical section. These emulated primitives exist to
|
||||
ensure that there is always a fallback if no machine-dependent version of a
|
||||
particular operation has been defined. They also serve as a very readable
|
||||
reference for the exact semantics of our OPA_* ops.
|
||||
*/
|
||||
|
||||
static _opa_inline int OPA_load_int(_opa_const OPA_int_t *ptr)
|
||||
{
|
||||
int retval;
|
||||
OPA_IPC_SINGLE_CS_ENTER("atomic_add");
|
||||
retval = ptr->v;
|
||||
OPA_IPC_SINGLE_CS_EXIT("atomic_add");
|
||||
return retval;
|
||||
}
|
||||
|
||||
static _opa_inline void OPA_store_int(OPA_int_t *ptr, int val)
|
||||
{
|
||||
OPA_IPC_SINGLE_CS_ENTER("atomic_add");
|
||||
ptr->v = val;
|
||||
OPA_IPC_SINGLE_CS_EXIT("atomic_add");
|
||||
}
|
||||
|
||||
static _opa_inline void *OPA_load_ptr(_opa_const OPA_ptr_t *ptr)
|
||||
{
|
||||
int *retval;
|
||||
OPA_IPC_SINGLE_CS_ENTER("atomic_add");
|
||||
retval = ptr->v;
|
||||
OPA_IPC_SINGLE_CS_EXIT("atomic_add");
|
||||
return retval;
|
||||
}
|
||||
|
||||
static _opa_inline void OPA_store_ptr(OPA_ptr_t *ptr, void *val)
|
||||
{
|
||||
OPA_IPC_SINGLE_CS_ENTER("atomic_add");
|
||||
ptr->v = val;
|
||||
OPA_IPC_SINGLE_CS_EXIT("atomic_add");
|
||||
}
|
||||
|
||||
/* normal loads/stores are fully ordered, so just use them */
|
||||
#define OPA_load_acquire_int(ptr_) OPA_load_int((ptr_))
|
||||
#define OPA_store_release_int(ptr_,val_) OPA_store_int((ptr_),(val_))
|
||||
#define OPA_load_acquire_ptr(ptr_) OPA_load_ptr((ptr_))
|
||||
#define OPA_store_release_ptr(ptr_,val_) OPA_store_ptr((ptr_),(val_))
|
||||
|
||||
static _opa_inline void OPA_add_int(OPA_int_t *ptr, int val)
|
||||
{
|
||||
OPA_IPC_SINGLE_CS_ENTER("atomic_add");
|
||||
ptr->v += val;
|
||||
OPA_IPC_SINGLE_CS_EXIT("atomic_add");
|
||||
}
|
||||
|
||||
static _opa_inline void *OPA_cas_ptr(OPA_ptr_t *ptr, int *oldv, int *newv)
|
||||
{
|
||||
int *prev;
|
||||
OPA_IPC_SINGLE_CS_ENTER("atomic_cas");
|
||||
prev = ptr->v;
|
||||
if (prev == oldv) {
|
||||
ptr->v = newv;
|
||||
}
|
||||
OPA_IPC_SINGLE_CS_EXIT("atomic_cas");
|
||||
return prev;
|
||||
}
|
||||
|
||||
static _opa_inline int OPA_cas_int(OPA_int_t *ptr, int oldv, int newv)
|
||||
{
|
||||
int prev;
|
||||
OPA_IPC_SINGLE_CS_ENTER("atomic_cas");
|
||||
prev = ptr->v;
|
||||
if (prev == oldv) {
|
||||
ptr->v = newv;
|
||||
}
|
||||
OPA_IPC_SINGLE_CS_EXIT("atomic_cas");
|
||||
return prev;
|
||||
}
|
||||
|
||||
static _opa_inline int OPA_decr_and_test_int(OPA_int_t *ptr)
|
||||
{
|
||||
int new_val;
|
||||
OPA_IPC_SINGLE_CS_ENTER("atomic_decr_and_test");
|
||||
new_val = --(ptr->v);
|
||||
OPA_IPC_SINGLE_CS_EXIT("atomic_decr_and_test");
|
||||
return (0 == new_val);
|
||||
}
|
||||
|
||||
static _opa_inline void OPA_decr_int(OPA_int_t *ptr)
|
||||
{
|
||||
OPA_IPC_SINGLE_CS_ENTER("atomic_decr");
|
||||
--(ptr->v);
|
||||
OPA_IPC_SINGLE_CS_EXIT("atomic_decr");
|
||||
}
|
||||
|
||||
static _opa_inline int OPA_fetch_and_add_int(OPA_int_t *ptr, int val)
|
||||
{
|
||||
int prev;
|
||||
OPA_IPC_SINGLE_CS_ENTER("atomic_fetch_and_add");
|
||||
prev = ptr->v;
|
||||
ptr->v += val;
|
||||
OPA_IPC_SINGLE_CS_EXIT("atomic_fetch_and_add");
|
||||
return prev;
|
||||
}
|
||||
|
||||
static _opa_inline int OPA_fetch_and_decr_int(OPA_int_t *ptr)
|
||||
{
|
||||
int prev;
|
||||
OPA_IPC_SINGLE_CS_ENTER("atomic_fetch_and_decr");
|
||||
prev = ptr->v;
|
||||
--(ptr->v);
|
||||
OPA_IPC_SINGLE_CS_EXIT("atomic_fetch_and_decr");
|
||||
return prev;
|
||||
}
|
||||
|
||||
static _opa_inline int OPA_fetch_and_incr_int(OPA_int_t *ptr)
|
||||
{
|
||||
int prev;
|
||||
OPA_IPC_SINGLE_CS_ENTER("atomic_fetch_and_incr");
|
||||
prev = ptr->v;
|
||||
++(ptr->v);
|
||||
OPA_IPC_SINGLE_CS_EXIT("atomic_fetch_and_incr");
|
||||
return prev;
|
||||
}
|
||||
|
||||
static _opa_inline void OPA_incr_int(OPA_int_t *ptr)
|
||||
{
|
||||
OPA_IPC_SINGLE_CS_ENTER("atomic_incr");
|
||||
++(ptr->v);
|
||||
OPA_IPC_SINGLE_CS_EXIT("atomic_incr");
|
||||
}
|
||||
|
||||
static _opa_inline void *OPA_swap_ptr(OPA_ptr_t *ptr, void *val)
|
||||
{
|
||||
int *prev;
|
||||
OPA_IPC_SINGLE_CS_ENTER("atomic_swap_ptr");
|
||||
prev = ptr->v;
|
||||
ptr->v = val;
|
||||
OPA_IPC_SINGLE_CS_EXIT("atomic_swap_ptr");
|
||||
return prev;
|
||||
}
|
||||
|
||||
static _opa_inline int OPA_swap_int(OPA_int_t *ptr, int val)
|
||||
{
|
||||
int prev;
|
||||
OPA_IPC_SINGLE_CS_ENTER("atomic_swap_int");
|
||||
prev = ptr->v;
|
||||
ptr->v = val;
|
||||
OPA_IPC_SINGLE_CS_EXIT("atomic_swap_int");
|
||||
return (int)prev;
|
||||
}
|
||||
|
||||
/* lock/unlock provides barrier */
|
||||
#define OPA_write_barrier() do {} while (0)
|
||||
#define OPA_read_barrier() do {} while (0)
|
||||
#define OPA_read_write_barrier() do {} while (0)
|
||||
|
||||
|
||||
#endif /* defined(OPA_HAVE_PTHREAD_H) */
|
||||
#endif /* !defined(OPA_BY_LOCK_H_INCLUDED) */
|
||||
@@ -1,192 +0,0 @@
|
||||
/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */
|
||||
/*
|
||||
* (C) 2008 by Argonne National Laboratory.
|
||||
* See COPYRIGHT in top-level directory.
|
||||
*/
|
||||
|
||||
#ifndef OPA_EMULATED_H_INCLUDED
|
||||
#define OPA_EMULATED_H_INCLUDED
|
||||
|
||||
/* Functions emulated using other atomics
|
||||
|
||||
This header should be included at the bottom of any atomic
|
||||
primitives header that needs to implement an atomic op in terms of
|
||||
another atomic.
|
||||
*/
|
||||
|
||||
/* Emulating using LL/SC */
|
||||
#if defined(OPA_LL_SC_SUPPORTED)
|
||||
static _opa_inline int OPA_fetch_and_add_int_by_llsc(OPA_int_t *ptr, int val)
|
||||
{
|
||||
int prev;
|
||||
do {
|
||||
prev = OPA_LL_int(ptr);
|
||||
} while (!OPA_SC_int(ptr, prev + val));
|
||||
return prev;
|
||||
}
|
||||
|
||||
|
||||
static _opa_inline void OPA_add_int_by_llsc(OPA_int_t *ptr, int val)
|
||||
{
|
||||
OPA_fetch_and_add_int_by_llsc(ptr, val);
|
||||
}
|
||||
|
||||
static _opa_inline void OPA_incr_int_by_llsc(OPA_int_t *ptr)
|
||||
{
|
||||
OPA_add_int_by_llsc(ptr, 1);
|
||||
}
|
||||
|
||||
static _opa_inline void OPA_decr_int_by_llsc(OPA_int_t *ptr)
|
||||
{
|
||||
OPA_add_int_by_llsc(ptr, -1);
|
||||
}
|
||||
|
||||
|
||||
static _opa_inline int OPA_fetch_and_decr_int_by_llsc(OPA_int_t *ptr)
|
||||
{
|
||||
return OPA_fetch_and_add_int_by_llsc(ptr, -1);
|
||||
}
|
||||
|
||||
static _opa_inline int OPA_fetch_and_incr_int_by_llsc(OPA_int_t *ptr)
|
||||
{
|
||||
return OPA_fetch_and_add_int_by_llsc(ptr, 1);
|
||||
}
|
||||
|
||||
static _opa_inline int OPA_decr_and_test_int_by_llsc(OPA_int_t *ptr)
|
||||
{
|
||||
int prev = OPA_fetch_and_decr_int_by_llsc(ptr);
|
||||
return prev == 1;
|
||||
}
|
||||
|
||||
static _opa_inline void *OPA_cas_ptr_by_llsc(OPA_ptr_t *ptr, void *oldv, void *newv)
|
||||
{
|
||||
void *prev;
|
||||
do {
|
||||
prev = OPA_LL_ptr(ptr);
|
||||
} while (prev == oldv && !OPA_SC_ptr(ptr, newv));
|
||||
return prev;
|
||||
}
|
||||
|
||||
static _opa_inline int OPA_cas_int_by_llsc(OPA_int_t *ptr, int oldv, int newv)
|
||||
{
|
||||
int prev;
|
||||
do {
|
||||
prev = OPA_LL_int(ptr);
|
||||
} while (prev == oldv && !OPA_SC_int(ptr, newv));
|
||||
return prev;
|
||||
}
|
||||
|
||||
|
||||
static _opa_inline void *OPA_swap_ptr_by_llsc(OPA_ptr_t *ptr, void *val)
|
||||
{
|
||||
void *prev;
|
||||
do {
|
||||
prev = OPA_LL_ptr(ptr);
|
||||
} while (!OPA_SC_ptr(ptr, val));
|
||||
return prev;
|
||||
}
|
||||
|
||||
static _opa_inline int OPA_swap_int_by_llsc(OPA_int_t *ptr, int val)
|
||||
{
|
||||
int prev;
|
||||
do {
|
||||
prev = OPA_LL_int(ptr);
|
||||
} while (!OPA_SC_int(ptr, val));
|
||||
return prev;
|
||||
}
|
||||
|
||||
#endif /* OPA_LL_SC_SUPPORTED */
|
||||
|
||||
static _opa_inline int OPA_fetch_and_add_int_by_cas(OPA_int_t *ptr, int val)
|
||||
{
|
||||
int cmp;
|
||||
int prev = OPA_load_int(ptr);
|
||||
|
||||
do {
|
||||
cmp = prev;
|
||||
prev = OPA_cas_int(ptr, cmp, prev + val);
|
||||
} while (prev != cmp);
|
||||
|
||||
return prev;
|
||||
}
|
||||
|
||||
static _opa_inline int OPA_fetch_and_incr_int_by_faa(OPA_int_t *ptr)
|
||||
{
|
||||
return OPA_fetch_and_add_int(ptr, 1);
|
||||
}
|
||||
|
||||
static _opa_inline int OPA_fetch_and_decr_int_by_faa(OPA_int_t *ptr)
|
||||
{
|
||||
return OPA_fetch_and_add_int(ptr, -1);
|
||||
}
|
||||
|
||||
static _opa_inline int OPA_decr_and_test_int_by_fad(OPA_int_t *ptr)
|
||||
{
|
||||
return OPA_fetch_and_decr_int(ptr) == 1;
|
||||
}
|
||||
|
||||
static _opa_inline void OPA_add_int_by_faa(OPA_int_t *ptr, int val)
|
||||
{
|
||||
OPA_fetch_and_add_int(ptr, val);
|
||||
}
|
||||
|
||||
static _opa_inline int OPA_incr_int_by_faa(OPA_int_t *ptr)
|
||||
{
|
||||
return OPA_fetch_and_add_int(ptr, 1);
|
||||
}
|
||||
|
||||
static _opa_inline void OPA_incr_int_by_add(OPA_int_t *ptr)
|
||||
{
|
||||
OPA_add_int(ptr, 1);
|
||||
}
|
||||
|
||||
static _opa_inline void OPA_incr_int_by_fai(OPA_int_t *ptr)
|
||||
{
|
||||
OPA_fetch_and_incr_int(ptr);
|
||||
}
|
||||
|
||||
static _opa_inline int OPA_decr_int_by_faa(OPA_int_t *ptr)
|
||||
{
|
||||
return OPA_fetch_and_add_int(ptr, -1);
|
||||
}
|
||||
|
||||
static _opa_inline void OPA_decr_int_by_add(OPA_int_t *ptr)
|
||||
{
|
||||
OPA_add_int(ptr, -1);
|
||||
}
|
||||
|
||||
static _opa_inline void OPA_decr_int_by_fad(OPA_int_t *ptr)
|
||||
{
|
||||
OPA_fetch_and_decr_int(ptr);
|
||||
}
|
||||
|
||||
|
||||
/* Swap using CAS */
|
||||
|
||||
static _opa_inline void *OPA_swap_ptr_by_cas(OPA_ptr_t *ptr, void *val)
|
||||
{
|
||||
void *cmp;
|
||||
void *prev = OPA_load_ptr(ptr);
|
||||
|
||||
do {
|
||||
cmp = prev;
|
||||
prev = OPA_cas_ptr(ptr, cmp, val);
|
||||
} while (prev != cmp);
|
||||
|
||||
return prev;
|
||||
}
|
||||
|
||||
static _opa_inline int OPA_swap_int_by_cas(OPA_int_t *ptr, int val)
|
||||
{
|
||||
int cmp;
|
||||
int prev = OPA_load_int(ptr);
|
||||
|
||||
do {
|
||||
cmp = prev;
|
||||
prev = OPA_cas_int(ptr, cmp, val);
|
||||
} while (prev != cmp);
|
||||
|
||||
return prev;
|
||||
}
|
||||
|
||||
#endif /* OPA_EMULATED_H_INCLUDED */
|
||||
@@ -1,216 +0,0 @@
|
||||
/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */
|
||||
/*
|
||||
* (C) 2008 by Argonne National Laboratory.
|
||||
* See COPYRIGHT in top-level directory.
|
||||
*/
|
||||
|
||||
/* NOTE: We (@ANL) do not have easy access to any ia64 hosts, so it is difficult
|
||||
* to develop and test updates to this file. Any help in this regard is greatly
|
||||
* appreciated. */
|
||||
|
||||
#ifndef OPA_GCC_IA64_H_INCLUDED
|
||||
#define OPA_GCC_IA64_H_INCLUDED
|
||||
|
||||
/* FIXME do we need to align these? */
|
||||
typedef struct { volatile int v; } OPA_int_t;
|
||||
typedef struct { void * volatile v; } OPA_ptr_t;
|
||||
|
||||
#define OPA_INT_T_INITIALIZER(val_) { (val_) }
|
||||
#define OPA_PTR_T_INITIALIZER(val_) { (val_) }
|
||||
|
||||
/* Aligned loads and stores are atomic on ia64. */
|
||||
static _opa_inline int OPA_load_int(_opa_const OPA_int_t *ptr)
|
||||
{
|
||||
return ptr->v;
|
||||
}
|
||||
|
||||
/* Aligned loads and stores are atomic on ia64. */
|
||||
static _opa_inline void OPA_store_int(OPA_int_t *ptr, int val)
|
||||
{
|
||||
ptr->v = val;
|
||||
}
|
||||
|
||||
/* Aligned loads and stores are atomic on ia64. */
|
||||
static _opa_inline void *OPA_load_ptr(_opa_const OPA_ptr_t *ptr)
|
||||
{
|
||||
return ptr->v;
|
||||
}
|
||||
|
||||
/* Aligned loads and stores are atomic on ia64. */
|
||||
static _opa_inline void OPA_store_ptr(OPA_ptr_t *ptr, void *val)
|
||||
{
|
||||
ptr->v = val;
|
||||
}
|
||||
|
||||
|
||||
/* NOTE-IA64-1 ia64 suports half-fence suffixes to ld/st instructions. It seems
|
||||
* that compilers also treat any C-language load/store from/to a volatile
|
||||
* variable as acquire/release and append the corresponding suffix accordingly.
|
||||
* But we don't have extensive testing to back this up, so we'll explicitly
|
||||
* force these instructions for now. When using the C-level approach, it's not
|
||||
* clear what instructions the compiler is allowed to reorder. */
|
||||
|
||||
#if 0
|
||||
/* acquire means operations after the acquire will see any memory opeations
|
||||
* performed before the corresponding paired release operation */
|
||||
static _opa_inline int OPA_load_acquire_int(_opa_const OPA_int_t *ptr)
|
||||
{
|
||||
int tmp;
|
||||
__asm__ __volatile__ ("ld.acq %0=[%1]"
|
||||
: "=r" (tmp)
|
||||
: "r" (ptr->v)
|
||||
: "memory");
|
||||
return tmp;
|
||||
}
|
||||
static _opa_inline void OPA_store_release_int(OPA_int_t *ptr, int val)
|
||||
{
|
||||
__asm__ __volatile__ ("st.rel [%0]=%1"
|
||||
: "=m" (ptr->v)
|
||||
: "r" (val)
|
||||
: "memory");
|
||||
}
|
||||
static _opa_inline void *OPA_load_acquire_ptr(_opa_const OPA_ptr_t *ptr)
|
||||
{
|
||||
int tmp;
|
||||
__asm__ __volatile__ ("ld.acq %0=[%1]"
|
||||
: "=r" (tmp)
|
||||
: "r" (ptr->v)
|
||||
: "memory");
|
||||
return tmp;
|
||||
}
|
||||
static _opa_inline void OPA_store_release_ptr(OPA_ptr_t *ptr, void *val)
|
||||
{
|
||||
__asm__ __volatile__ ("st.rel [%0]=%1"
|
||||
: "=m" (ptr->v)
|
||||
: "r" (val)
|
||||
: "memory");
|
||||
}
|
||||
#else
|
||||
/* FIXME because we can't test these implementations, they are currently
|
||||
* disabled. The above impls are rough starting points, but probably won't
|
||||
* compile/assemble correctly as-is. Patches are welcome :) */
|
||||
#define OPA_load_acquire_int(ptr_) ::"choke me"
|
||||
#define OPA_store_release_int(ptr_,val_) ::"choke me"
|
||||
#define OPA_load_acquire_ptr(ptr_) ::"choke me"
|
||||
#define OPA_store_release_ptr(ptr_,val_) ::"choke me"
|
||||
#endif
|
||||
|
||||
|
||||
#define OPA_add_int_by_faa OPA_add_int
|
||||
#define OPA_incr_int_by_faa OPA_incr_int
|
||||
#define OPA_decr_int_by_faa OPA_decr_int
|
||||
#define OPA_fetch_and_decr_int_by_faa OPA_fetch_and_decr_int
|
||||
#define OPA_fetch_and_incr_int_by_faa OPA_fetch_and_incr_int
|
||||
|
||||
static _opa_inline int OPA_decr_and_test_int(OPA_int_t *ptr)
|
||||
{
|
||||
int val;
|
||||
__asm__ __volatile__ ("fetchadd4.rel %0=[%2],%3"
|
||||
: "=r"(val), "=m"(ptr->v)
|
||||
: "r"(&ptr->v), "i"(-1));
|
||||
return val == 1;
|
||||
}
|
||||
|
||||
static _opa_inline int OPA_cas_int(OPA_int_t *ptr, int oldv, int newv)
|
||||
{
|
||||
int prev;
|
||||
|
||||
#if OPA_SIZEOF_INT == 8
|
||||
__asm__ __volatile__ ("mov ar.ccv=%1;;"
|
||||
"cmpxchg8.rel %0=[%3],%4,ar.ccv"
|
||||
: "=r"(prev), "=m"(ptr->v)
|
||||
: "rO"(oldv), "r"(&ptr->v), "r"(newv)
|
||||
: "memory");
|
||||
break;
|
||||
#elif OPA_SIZEOF_INT == 4
|
||||
__asm__ __volatile__ ("zxt4 %1=%1;;" /* don't want oldv sign-extended to 64 bits */
|
||||
"mov ar.ccv=%1;;"
|
||||
"cmpxchg4.rel %0=[%3],%4,ar.ccv"
|
||||
: "=r"(prev), "=m"(ptr->v)
|
||||
: "r0"(oldv), "r"(&ptr->v), "r"(newv)
|
||||
: "memory");
|
||||
#else
|
||||
#error OPA_SIZEOF_INT is not 4 or 8
|
||||
#endif
|
||||
|
||||
return prev;
|
||||
}
|
||||
|
||||
/* IA64 has a fetch-and-add instruction that only accepts immediate
|
||||
values of -16, -8, -4, -1, 1, 4, 8, and 16. So we check for these
|
||||
values before falling back to the CAS implementation. */
|
||||
#define OPA_IA64_FAA_CASE_MACRO(ptr, val) case val: { \
|
||||
int prev; \
|
||||
__asm__ __volatile__ ("fetchadd4.rel %0=[%2],%3" \
|
||||
: "=r"(prev), "=m"(ptr->v) \
|
||||
: "r"(&ptr->v), "i"(val)); \
|
||||
return prev; \
|
||||
} \
|
||||
break
|
||||
|
||||
|
||||
static _opa_inline int OPA_fetch_and_add_int(OPA_int_t *ptr, int val)
|
||||
{
|
||||
switch (val)
|
||||
{
|
||||
OPA_IA64_FAA_CASE_MACRO(ptr, -16);
|
||||
OPA_IA64_FAA_CASE_MACRO(ptr, -8);
|
||||
OPA_IA64_FAA_CASE_MACRO(ptr, -4);
|
||||
OPA_IA64_FAA_CASE_MACRO(ptr, -1);
|
||||
OPA_IA64_FAA_CASE_MACRO(ptr, 1);
|
||||
OPA_IA64_FAA_CASE_MACRO(ptr, 4);
|
||||
OPA_IA64_FAA_CASE_MACRO(ptr, 8);
|
||||
OPA_IA64_FAA_CASE_MACRO(ptr, 16);
|
||||
default:
|
||||
{
|
||||
int cmp;
|
||||
int prev = OPA_load_int(ptr);
|
||||
|
||||
do {
|
||||
cmp = prev;
|
||||
prev = OPA_cas_int(ptr, cmp, val);
|
||||
} while (prev != cmp);
|
||||
|
||||
return prev;
|
||||
}
|
||||
}
|
||||
}
|
||||
#undef OPA_IA64_FAA_CASE_MACRO
|
||||
|
||||
|
||||
static _opa_inline void *OPA_cas_ptr(OPA_ptr_t *ptr, void *oldv, void *newv)
|
||||
{
|
||||
void *prev;
|
||||
__asm__ __volatile__ ("mov ar.ccv=%1;;"
|
||||
"cmpxchg8.rel %0=[%3],%4,ar.ccv"
|
||||
: "=r"(prev), "=m"(ptr->v)
|
||||
: "rO"(oldv), "r"(&ptr->v), "r"(newv));
|
||||
return prev;
|
||||
}
|
||||
|
||||
static _opa_inline void *OPA_swap_ptr(OPA_ptr_t *ptr, void *val)
|
||||
{
|
||||
__asm__ __volatile__ ("xchg8 %0=[%2],%3"
|
||||
: "=r" (val), "=m" (ptr->v)
|
||||
: "r" (&ptr->v), "0" (val));
|
||||
return val;
|
||||
}
|
||||
|
||||
|
||||
static _opa_inline int OPA_swap_int(OPA_int_t *ptr, int val)
|
||||
{
|
||||
__asm__ __volatile__ ("xchg8 %0=[%2],%3"
|
||||
: "=r" (val), "=m" (ptr->v)
|
||||
: "r" (&ptr->v), "0" (val));
|
||||
return val;
|
||||
}
|
||||
|
||||
|
||||
#define OPA_write_barrier() __asm__ __volatile__ ("mf" ::: "memory" )
|
||||
#define OPA_read_barrier() __asm__ __volatile__ ("mf" ::: "memory" )
|
||||
#define OPA_read_write_barrier() __asm__ __volatile__ ("mf" ::: "memory" )
|
||||
#define OPA_compiler_barrier() __asm__ __volatile__ ("" ::: "memory" )
|
||||
|
||||
#include "opa_emulated.h"
|
||||
|
||||
#endif /* OPA_GCC_IA64_H_INCLUDED */
|
||||
@@ -1,15 +0,0 @@
|
||||
/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */
|
||||
/*
|
||||
* (C) 2008 by Argonne National Laboratory.
|
||||
* See COPYRIGHT in top-level directory.
|
||||
*/
|
||||
|
||||
#ifndef OPA_GCC_INTEL_32_64_H_INCLUDED
|
||||
#define OPA_GCC_INTEL_32_64_H_INCLUDED
|
||||
|
||||
#include "opa_gcc_intel_32_64_barrier.h"
|
||||
#include "opa_gcc_intel_32_64_ops.h"
|
||||
|
||||
#include "opa_emulated.h"
|
||||
|
||||
#endif /* OPA_GCC_INTEL_32_64_H_INCLUDED */
|
||||
@@ -1,25 +0,0 @@
|
||||
/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */
|
||||
/*
|
||||
* (C) 2008 by Argonne National Laboratory.
|
||||
* See COPYRIGHT in top-level directory.
|
||||
*/
|
||||
|
||||
#ifndef OPA_GCC_INTEL_32_64_BARRIER_H_INCLUDED
|
||||
#define OPA_GCC_INTEL_32_64_BARRIER_H_INCLUDED
|
||||
|
||||
#define OPA_compiler_barrier() __asm__ __volatile__ ( "" ::: "memory" )
|
||||
|
||||
/* For all regular memory (write-back cacheable, not driver/graphics
|
||||
* memory), there is only one general ordering relaxation permitted by
|
||||
* x86/x86_64 processors: earlier stores may be retired after later
|
||||
* stores. The "clflush" and "movnt*" instructions also don't follow
|
||||
* general ordering constraints, although any code using these
|
||||
* instructions should be responsible for ensuring proper ordering
|
||||
* itself. So our read and write barriers may be implemented as simple
|
||||
* compiler barriers. */
|
||||
#define OPA_write_barrier() OPA_compiler_barrier()
|
||||
#define OPA_read_barrier() OPA_compiler_barrier()
|
||||
|
||||
#define OPA_read_write_barrier() __asm__ __volatile__ ( "mfence" ::: "memory" )
|
||||
|
||||
#endif /* OPA_GCC_INTEL_32_64_BARRIER_H_INCLUDED */
|
||||
@@ -1,173 +0,0 @@
|
||||
/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */
|
||||
/*
|
||||
* (C) 2008 by Argonne National Laboratory.
|
||||
* See COPYRIGHT in top-level directory.
|
||||
*/
|
||||
|
||||
#ifndef OPA_GCC_INTEL_32_64_OPS_H_INCLUDED
|
||||
#define OPA_GCC_INTEL_32_64_OPS_H_INCLUDED
|
||||
|
||||
#ifndef OPA_SIZEOF_INT
|
||||
#error OPA_SIZEOF_INT is not defined
|
||||
#endif
|
||||
|
||||
/* Set OPA_SS (Size Suffix) which is to be appended to asm ops for
|
||||
specifying 4 or 8 byte operands */
|
||||
#if OPA_SIZEOF_INT == 4
|
||||
#define OPA_SS "l"
|
||||
#elif OPA_SIZEOF_INT == 8
|
||||
#define OPA_SS "q"
|
||||
#else
|
||||
#error OPA_SIZEOF_INT is not 4 or 8
|
||||
#endif
|
||||
|
||||
/* XXX DJG FIXME do we need to align these? */
|
||||
typedef struct { volatile int v; } OPA_int_t;
|
||||
typedef struct { void * volatile v; } OPA_ptr_t;
|
||||
|
||||
#define OPA_INT_T_INITIALIZER(val_) { (val_) }
|
||||
#define OPA_PTR_T_INITIALIZER(val_) { (val_) }
|
||||
|
||||
/* Aligned loads and stores are atomic on x86(-64). */
|
||||
static _opa_inline int OPA_load_int(_opa_const OPA_int_t *ptr)
|
||||
{
|
||||
return ptr->v;
|
||||
}
|
||||
|
||||
/* Aligned loads and stores are atomic on x86(-64). */
|
||||
static _opa_inline void OPA_store_int(OPA_int_t *ptr, int val)
|
||||
{
|
||||
ptr->v = val;
|
||||
}
|
||||
|
||||
/* Aligned loads and stores are atomic on x86(-64). */
|
||||
static _opa_inline void *OPA_load_ptr(_opa_const OPA_ptr_t *ptr)
|
||||
{
|
||||
return ptr->v;
|
||||
}
|
||||
|
||||
/* Aligned loads and stores are atomic on x86(-64). */
|
||||
static _opa_inline void OPA_store_ptr(OPA_ptr_t *ptr, void *val)
|
||||
{
|
||||
ptr->v = val;
|
||||
}
|
||||
|
||||
/* NOTE-X86-1 x86 and x86_64 processors execute instructions such that their
|
||||
* effects are visible in issue order, with one exception: earlier stores may
|
||||
* pass later loads. Also, non-temporal stores (with the "movnt*" instructions)
|
||||
* do not follow these ordering constraints. So all normal load/store
|
||||
* instructions on x86(_64) already have acquire/release semantics. We just
|
||||
* have to make sure that the compiler does not reorder the instructions. */
|
||||
|
||||
static _opa_inline int OPA_load_acquire_int(_opa_const OPA_int_t *ptr)
|
||||
{
|
||||
int tmp;
|
||||
tmp = ptr->v;
|
||||
OPA_compiler_barrier(); /* NOTE-X86-1 */
|
||||
return tmp;
|
||||
}
|
||||
|
||||
static _opa_inline void OPA_store_release_int(OPA_int_t *ptr, int val)
|
||||
{
|
||||
OPA_compiler_barrier(); /* NOTE-X86-1 */
|
||||
ptr->v = val;
|
||||
}
|
||||
|
||||
static _opa_inline void *OPA_load_acquire_ptr(_opa_const OPA_ptr_t *ptr)
|
||||
{
|
||||
void *tmp;
|
||||
tmp = ptr->v;
|
||||
OPA_compiler_barrier(); /* NOTE-X86-1 */
|
||||
return tmp;
|
||||
}
|
||||
|
||||
static _opa_inline void OPA_store_release_ptr(OPA_ptr_t *ptr, void *val)
|
||||
{
|
||||
OPA_compiler_barrier(); /* NOTE-X86-1 */
|
||||
ptr->v = val;
|
||||
}
|
||||
|
||||
|
||||
static _opa_inline void OPA_add_int(OPA_int_t *ptr, int val)
|
||||
{
|
||||
__asm__ __volatile__ ("lock ; add"OPA_SS" %1,%0"
|
||||
:"=m" (ptr->v)
|
||||
:"ir" (val), "m" (ptr->v));
|
||||
return;
|
||||
}
|
||||
|
||||
static _opa_inline void OPA_incr_int(OPA_int_t *ptr)
|
||||
{
|
||||
__asm__ __volatile__ ("lock ; inc"OPA_SS" %0"
|
||||
:"=m" (ptr->v)
|
||||
:"m" (ptr->v));
|
||||
return;
|
||||
}
|
||||
|
||||
static _opa_inline void OPA_decr_int(OPA_int_t *ptr)
|
||||
{
|
||||
__asm__ __volatile__ ("lock ; dec"OPA_SS" %0"
|
||||
:"=m" (ptr->v)
|
||||
:"m" (ptr->v));
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
static _opa_inline int OPA_decr_and_test_int(OPA_int_t *ptr)
|
||||
{
|
||||
char result;
|
||||
__asm__ __volatile__ ("lock ; dec"OPA_SS" %0; setz %1"
|
||||
:"=m" (ptr->v), "=q" (result)
|
||||
:"m" (ptr->v));
|
||||
return result;
|
||||
}
|
||||
|
||||
static _opa_inline int OPA_fetch_and_add_int(OPA_int_t *ptr, int val)
|
||||
{
|
||||
__asm__ __volatile__ ("lock ; xadd %0,%1"
|
||||
: "=r" (val), "=m" (ptr->v)
|
||||
: "0" (val), "m" (ptr->v));
|
||||
return val;
|
||||
}
|
||||
|
||||
#define OPA_fetch_and_incr_int_by_faa OPA_fetch_and_incr_int
|
||||
#define OPA_fetch_and_decr_int_by_faa OPA_fetch_and_decr_int
|
||||
|
||||
|
||||
static _opa_inline void *OPA_cas_ptr(OPA_ptr_t *ptr, void *oldv, void *newv)
|
||||
{
|
||||
void *prev;
|
||||
__asm__ __volatile__ ("lock ; cmpxchg %3,%4"
|
||||
: "=a" (prev), "=m" (ptr->v)
|
||||
: "0" (oldv), "q" (newv), "m" (ptr->v));
|
||||
return prev;
|
||||
}
|
||||
|
||||
static _opa_inline int OPA_cas_int(OPA_int_t *ptr, int oldv, int newv)
|
||||
{
|
||||
int prev;
|
||||
__asm__ __volatile__ ("lock ; cmpxchg %3,%4"
|
||||
: "=a" (prev), "=m" (ptr->v)
|
||||
: "0" (oldv), "q" (newv), "m" (ptr->v));
|
||||
return prev;
|
||||
}
|
||||
|
||||
static _opa_inline void *OPA_swap_ptr(OPA_ptr_t *ptr, void *val)
|
||||
{
|
||||
__asm__ __volatile__ ("xchg %0,%1"
|
||||
:"=r" (val), "=m" (ptr->v)
|
||||
: "0" (val), "m" (ptr->v));
|
||||
return val;
|
||||
}
|
||||
|
||||
static _opa_inline int OPA_swap_int(OPA_int_t *ptr, int val)
|
||||
{
|
||||
__asm__ __volatile__ ("xchg %0,%1"
|
||||
:"=r" (val), "=m" (ptr->v)
|
||||
: "0" (val), "m" (ptr->v));
|
||||
return val;
|
||||
}
|
||||
|
||||
#undef OPA_SS
|
||||
|
||||
#endif /* OPA_GCC_INTEL_32_64_OPS_H_INCLUDED */
|
||||
@@ -1,15 +0,0 @@
|
||||
/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */
|
||||
/*
|
||||
* (C) 2008 by Argonne National Laboratory.
|
||||
* See COPYRIGHT in top-level directory.
|
||||
*/
|
||||
|
||||
#ifndef OPA_GCC_INTEL_32_64_P3_H_INCLUDED
|
||||
#define OPA_GCC_INTEL_32_64_P3_H_INCLUDED
|
||||
|
||||
#include "opa_gcc_intel_32_64_p3barrier.h"
|
||||
#include "opa_gcc_intel_32_64_ops.h"
|
||||
|
||||
#include "opa_emulated.h"
|
||||
|
||||
#endif /* OPA_GCC_INTEL_32_64_P3_H_INCLUDED */
|
||||
@@ -1,34 +0,0 @@
|
||||
/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */
|
||||
/*
|
||||
* (C) 2008 by Argonne National Laboratory.
|
||||
* See COPYRIGHT in top-level directory.
|
||||
*/
|
||||
|
||||
#ifndef OPA_GCC_INTEL_32_64_P3BARRIER_H_INCLUDED
|
||||
#define OPA_GCC_INTEL_32_64_P3BARRIER_H_INCLUDED
|
||||
|
||||
#define OPA_compiler_barrier() __asm__ __volatile__ ( "" ::: "memory" )
|
||||
|
||||
/* For all regular memory (write-back cacheable, not driver/graphics
|
||||
* memory), there is only one general ordering relaxation permitted by
|
||||
* x86/x86_64 processors: earlier stores may be retired after later
|
||||
* stores. The "clflush" and "movnt*" instructions also don't follow
|
||||
* general ordering constraints, although any code using these
|
||||
* instructions should be responsible for ensuring proper ordering
|
||||
* itself. So our read and write barriers may be implemented as simple
|
||||
* compiler barriers. */
|
||||
#define OPA_write_barrier() OPA_compiler_barrier()
|
||||
#define OPA_read_barrier() OPA_compiler_barrier()
|
||||
|
||||
/* Some Pentium III and earlier processors have store barriers
|
||||
(sfence), but no full barrier or load barriers. Some other very
|
||||
recent x86-like processors don't seem to have sfence either. A
|
||||
lock-prefixed atomic instruction (operating on any memory) behaves as
|
||||
a full memory barrier, so we use that here. */
|
||||
static inline void OPA_read_write_barrier(void)
|
||||
{
|
||||
int a = 0;
|
||||
__asm__ __volatile__ ("lock orl $0, %0" : "+m" (a) : /*no outputs*/ : "memory");
|
||||
}
|
||||
|
||||
#endif /* OPA_GCC_INTEL_32_64_P3BARRIER_H_INCLUDED */
|
||||
@@ -1,129 +0,0 @@
|
||||
/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */
|
||||
/*
|
||||
* (C) 2008 by Argonne National Laboratory.
|
||||
* See COPYRIGHT in top-level directory.
|
||||
*/
|
||||
|
||||
/* FIXME needs to be converted to new style functions with OPA_int_t/OPA_ptr_t-types */
|
||||
#ifndef OPA_GCC_INTRINSICS_H_INCLUDED
|
||||
#define OPA_GCC_INTRINSICS_H_INCLUDED
|
||||
|
||||
/* FIXME do we need to align these? */
|
||||
typedef struct { volatile int v; } OPA_int_t;
|
||||
typedef struct { void * volatile v; } OPA_ptr_t;
|
||||
|
||||
#define OPA_INT_T_INITIALIZER(val_) { (val_) }
|
||||
#define OPA_PTR_T_INITIALIZER(val_) { (val_) }
|
||||
|
||||
/* Assume that loads/stores are atomic on the current platform, even though this
|
||||
may not be true at all. */
|
||||
static _opa_inline int OPA_load_int(_opa_const OPA_int_t *ptr)
|
||||
{
|
||||
return ptr->v;
|
||||
}
|
||||
|
||||
static _opa_inline void OPA_store_int(OPA_int_t *ptr, int val)
|
||||
{
|
||||
ptr->v = val;
|
||||
}
|
||||
|
||||
static _opa_inline void *OPA_load_ptr(_opa_const OPA_ptr_t *ptr)
|
||||
{
|
||||
return ptr->v;
|
||||
}
|
||||
|
||||
static _opa_inline void OPA_store_ptr(OPA_ptr_t *ptr, void *val)
|
||||
{
|
||||
ptr->v = val;
|
||||
}
|
||||
|
||||
static _opa_inline int OPA_load_acquire_int(_opa_const OPA_int_t *ptr)
|
||||
{
|
||||
volatile int i = 0;
|
||||
int tmp;
|
||||
tmp = ptr->v;
|
||||
__sync_lock_test_and_set(&i, 1); /* guarantees acquire semantics */
|
||||
return tmp;
|
||||
}
|
||||
|
||||
static _opa_inline void OPA_store_release_int(OPA_int_t *ptr, int val)
|
||||
{
|
||||
volatile int i = 1;
|
||||
__sync_lock_release(&i); /* guarantees release semantics */
|
||||
ptr->v = val;
|
||||
}
|
||||
|
||||
static _opa_inline void *OPA_load_acquire_ptr(_opa_const OPA_ptr_t *ptr)
|
||||
{
|
||||
volatile int i = 0;
|
||||
void *tmp;
|
||||
tmp = ptr->v;
|
||||
__sync_lock_test_and_set(&i, 1); /* guarantees acquire semantics */
|
||||
return tmp;
|
||||
}
|
||||
|
||||
static _opa_inline void OPA_store_release_ptr(OPA_ptr_t *ptr, void *val)
|
||||
{
|
||||
volatile int i = 1;
|
||||
__sync_lock_release(&i); /* guarantees release semantics */
|
||||
ptr->v = val;
|
||||
}
|
||||
|
||||
|
||||
/* gcc atomic intrinsics accept an optional list of variables to be
|
||||
protected by a memory barrier. These variables are labeled
|
||||
below by "protected variables :". */
|
||||
|
||||
static _opa_inline int OPA_fetch_and_add_int(OPA_int_t *ptr, int val)
|
||||
{
|
||||
return __sync_fetch_and_add(&ptr->v, val, /* protected variables: */ &ptr->v);
|
||||
}
|
||||
|
||||
static _opa_inline int OPA_decr_and_test_int(OPA_int_t *ptr)
|
||||
{
|
||||
return __sync_sub_and_fetch(&ptr->v, 1, /* protected variables: */ &ptr->v) == 0;
|
||||
}
|
||||
|
||||
#define OPA_fetch_and_incr_int_by_faa OPA_fetch_and_incr_int
|
||||
#define OPA_fetch_and_decr_int_by_faa OPA_fetch_and_decr_int
|
||||
#define OPA_add_int_by_faa OPA_add_int
|
||||
#define OPA_incr_int_by_fai OPA_incr_int
|
||||
#define OPA_decr_int_by_fad OPA_decr_int
|
||||
|
||||
|
||||
static _opa_inline void *OPA_cas_ptr(OPA_ptr_t *ptr, void *oldv, void *newv)
|
||||
{
|
||||
return __sync_val_compare_and_swap(&ptr->v, oldv, newv, /* protected variables: */ &ptr->v);
|
||||
}
|
||||
|
||||
static _opa_inline int OPA_cas_int(OPA_int_t *ptr, int oldv, int newv)
|
||||
{
|
||||
return __sync_val_compare_and_swap(&ptr->v, oldv, newv, /* protected variables: */ &ptr->v);
|
||||
}
|
||||
|
||||
#ifdef SYNC_LOCK_TEST_AND_SET_IS_SWAP
|
||||
static _opa_inline void *OPA_swap_ptr(OPA_ptr_t *ptr, void *val)
|
||||
{
|
||||
return __sync_lock_test_and_set(&ptr->v, val, /* protected variables: */ &ptr->v);
|
||||
}
|
||||
|
||||
static _opa_inline int OPA_swap_int(OPA_int_t *ptr, int val)
|
||||
{
|
||||
return __sync_lock_test_and_set(&ptr->v, val, /* protected variables: */ &ptr->v);
|
||||
}
|
||||
|
||||
#else
|
||||
#define OPA_swap_ptr_by_cas OPA_swap_ptr
|
||||
#define OPA_swap_int_by_cas OPA_swap_int
|
||||
#endif
|
||||
|
||||
#define OPA_write_barrier() __sync_synchronize()
|
||||
#define OPA_read_barrier() __sync_synchronize()
|
||||
#define OPA_read_write_barrier() __sync_synchronize()
|
||||
#define OPA_compiler_barrier() __asm__ __volatile__ ( "" ::: "memory" )
|
||||
|
||||
|
||||
|
||||
#include"opa_emulated.h"
|
||||
|
||||
#endif /* OPA_GCC_INTRINSICS_H_INCLUDED */
|
||||
@@ -1,180 +0,0 @@
|
||||
/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */
|
||||
/*
|
||||
* (C) 2008 by Argonne National Laboratory.
|
||||
* See COPYRIGHT in top-level directory.
|
||||
*/
|
||||
|
||||
#ifndef OPA_GCC_PPC_H_INCLUDED
|
||||
#define OPA_GCC_PPC_H_INCLUDED
|
||||
|
||||
/* these need to be aligned on an 8-byte boundary to work on a BG/P */
|
||||
typedef struct { volatile int v OPA_ATTRIBUTE((aligned (8))); } OPA_int_t;
|
||||
typedef struct { void * volatile v OPA_ATTRIBUTE((aligned (8))); } OPA_ptr_t;
|
||||
|
||||
#define OPA_INT_T_INITIALIZER(val_) { (val_) }
|
||||
#define OPA_PTR_T_INITIALIZER(val_) { (val_) }
|
||||
|
||||
/* Aligned loads and stores are atomic. */
|
||||
static _opa_inline int OPA_load_int(_opa_const OPA_int_t *ptr)
|
||||
{
|
||||
return ptr->v;
|
||||
}
|
||||
|
||||
/* Aligned loads and stores are atomic. */
|
||||
static _opa_inline void OPA_store_int(OPA_int_t *ptr, int val)
|
||||
{
|
||||
ptr->v = val;
|
||||
}
|
||||
|
||||
/* Aligned loads and stores are atomic. */
|
||||
static _opa_inline void *OPA_load_ptr(_opa_const OPA_ptr_t *ptr)
|
||||
{
|
||||
return ptr->v;
|
||||
}
|
||||
|
||||
/* Aligned loads and stores are atomic. */
|
||||
static _opa_inline void OPA_store_ptr(OPA_ptr_t *ptr, void *val)
|
||||
{
|
||||
ptr->v = val;
|
||||
}
|
||||
|
||||
/* a useful link for PPC memory ordering issues:
|
||||
* http://www.rdrop.com/users/paulmck/scalability/paper/N2745r.2009.02.22a.html
|
||||
*
|
||||
* lwsync: orders L-L, S-S, L-S, but *not* S-L (i.e. gives x86-ish ordering)
|
||||
* eieio: orders S-S (but only for cacheable memory, not for MMIO)
|
||||
* sync: totally orders memops
|
||||
* isync: force all preceeding insns to appear complete before starting
|
||||
* subsequent insns, but w/o cumulativity (very confusing)
|
||||
*/
|
||||
/* helper macros */
|
||||
#define OPA_ppc_lwsync_() __asm__ __volatile__ ( "lwsync" ::: "memory" )
|
||||
#define OPA_ppc_hwsync_() __asm__ __volatile__ ( "sync" ::: "memory" )
|
||||
#define OPA_ppc_eieio_() __asm__ __volatile__ ( "eieio" ::: "memory" )
|
||||
|
||||
#define OPA_write_barrier() OPA_ppc_eieio_()
|
||||
#define OPA_read_barrier() OPA_ppc_lwsync_()
|
||||
#define OPA_read_write_barrier() OPA_ppc_hwsync_()
|
||||
#define OPA_compiler_barrier() __asm__ __volatile__ ( "" ::: "memory" )
|
||||
|
||||
/* NOTE-PPC-1 we use lwsync, although I think we might be able to use
|
||||
* conditional-branch+isync in some cases (load_acquire?) once we understand it
|
||||
* better */
|
||||
|
||||
static _opa_inline int OPA_load_acquire_int(_opa_const OPA_int_t *ptr)
|
||||
{
|
||||
int tmp;
|
||||
tmp = ptr->v;
|
||||
OPA_ppc_lwsync_(); /* NOTE-PPC-1 */
|
||||
return tmp;
|
||||
}
|
||||
static _opa_inline void OPA_store_release_int(OPA_int_t *ptr, int val)
|
||||
{
|
||||
OPA_ppc_lwsync_();
|
||||
ptr->v = val;
|
||||
}
|
||||
static _opa_inline void *OPA_load_acquire_ptr(_opa_const OPA_ptr_t *ptr)
|
||||
{
|
||||
void *tmp;
|
||||
tmp = ptr->v;
|
||||
OPA_ppc_lwsync_(); /* NOTE-PPC-1 */
|
||||
return tmp;
|
||||
}
|
||||
static _opa_inline void OPA_store_release_ptr(OPA_ptr_t *ptr, void *val)
|
||||
{
|
||||
OPA_ppc_lwsync_();
|
||||
ptr->v = val;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
load-link/store-conditional (LL/SC) primitives. We LL/SC implement
|
||||
these here, which are arch-specific, then use the generic
|
||||
implementations from opa_emulated.h */
|
||||
|
||||
static _opa_inline int OPA_LL_int(OPA_int_t *ptr)
|
||||
{
|
||||
int val;
|
||||
__asm__ __volatile__ ("lwarx %[val],0,%[ptr]"
|
||||
: [val] "=r" (val)
|
||||
: [ptr] "r" (&ptr->v)
|
||||
: "cc");
|
||||
|
||||
return val;
|
||||
}
|
||||
|
||||
/* Returns non-zero if the store was successful, zero otherwise. */
|
||||
static _opa_inline int OPA_SC_int(OPA_int_t *ptr, int val)
|
||||
{
|
||||
int ret = 1; /* init to non-zero, will be reset to 0 if SC was unsuccessful */
|
||||
__asm__ __volatile__ ("stwcx. %[val],0,%[ptr];\n"
|
||||
"beq 1f;\n"
|
||||
"li %[ret], 0;\n"
|
||||
"1: ;\n"
|
||||
: [ret] "=r" (ret)
|
||||
: [ptr] "r" (&ptr->v), [val] "r" (val), "0" (ret)
|
||||
: "cc", "memory");
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
/* Pointer versions of LL/SC. */
|
||||
|
||||
/* Set OPA_SS (Size Suffix) which is used to choose between lwarx/stwcx and
|
||||
* ldarx/stdcx when using 4 or 8 byte pointer operands */
|
||||
#if OPA_SIZEOF_VOID_P == 4
|
||||
#define OPA_SS "w"
|
||||
#elif OPA_SIZEOF_VOID_P == 8
|
||||
#define OPA_SS "d"
|
||||
#else
|
||||
#error OPA_SIZEOF_VOID_P is not 4 or 8
|
||||
#endif
|
||||
|
||||
|
||||
static _opa_inline void *OPA_LL_ptr(OPA_ptr_t *ptr)
|
||||
{
|
||||
void *val;
|
||||
__asm__ __volatile__ ("l"OPA_SS"arx %[val],0,%[ptr]"
|
||||
: [val] "=r" (val)
|
||||
: [ptr] "r" (&ptr->v)
|
||||
: "cc");
|
||||
|
||||
return val;
|
||||
}
|
||||
|
||||
/* Returns non-zero if the store was successful, zero otherwise. */
|
||||
static _opa_inline int OPA_SC_ptr(OPA_ptr_t *ptr, void *val)
|
||||
{
|
||||
int ret = 1; /* init to non-zero, will be reset to 0 if SC was unsuccessful */
|
||||
__asm__ __volatile__ ("st"OPA_SS"cx. %[val],0,%[ptr];\n"
|
||||
"beq 1f;\n"
|
||||
"li %[ret], 0;\n"
|
||||
"1: ;\n"
|
||||
: [ret] "=r" (ret)
|
||||
: [ptr] "r" (&ptr->v), [val] "r" (val), "0" (ret)
|
||||
: "cc", "memory");
|
||||
return ret;
|
||||
}
|
||||
|
||||
#undef OPA_SS
|
||||
|
||||
/* necessary to enable LL/SC emulation support */
|
||||
#define OPA_LL_SC_SUPPORTED 1
|
||||
|
||||
/* Implement all function using LL/SC */
|
||||
#define OPA_add_int_by_llsc OPA_add_int
|
||||
#define OPA_incr_int_by_llsc OPA_incr_int
|
||||
#define OPA_decr_int_by_llsc OPA_decr_int
|
||||
#define OPA_decr_and_test_int_by_llsc OPA_decr_and_test_int
|
||||
#define OPA_fetch_and_add_int_by_llsc OPA_fetch_and_add_int
|
||||
#define OPA_fetch_and_decr_int_by_llsc OPA_fetch_and_decr_int
|
||||
#define OPA_fetch_and_incr_int_by_llsc OPA_fetch_and_incr_int
|
||||
#define OPA_cas_ptr_by_llsc OPA_cas_ptr
|
||||
#define OPA_cas_int_by_llsc OPA_cas_int
|
||||
#define OPA_swap_ptr_by_llsc OPA_swap_ptr
|
||||
#define OPA_swap_int_by_llsc OPA_swap_int
|
||||
|
||||
|
||||
#include "opa_emulated.h"
|
||||
|
||||
#endif /* OPA_GCC_PPC_H_INCLUDED */
|
||||
@@ -1,443 +0,0 @@
|
||||
/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */
|
||||
/*
|
||||
* (C) 2008 by Argonne National Laboratory.
|
||||
* See COPYRIGHT in top-level directory.
|
||||
*/
|
||||
|
||||
/* Atomic primitives for SiCortex machines.
|
||||
* Originally contributed by Lawrence Stewart at SiCortex.
|
||||
*/
|
||||
|
||||
#ifndef OPA_GCC_SICORTEX_H
|
||||
#define OPA_GCC_SICORTEX_H
|
||||
|
||||
/* FIXME do these need alignment? */
|
||||
typedef struct { volatile int v; } OPA_int_t;
|
||||
typedef struct { int * volatile v; } OPA_ptr_t;
|
||||
|
||||
#define OPA_INT_T_INITIALIZER(val_) { (val_) }
|
||||
#define OPA_PTR_T_INITIALIZER(val_) { (val_) }
|
||||
|
||||
#define OPA_write_barrier() __asm__ __volatile__ ("sync" ::: "memory" )
|
||||
#define OPA_read_barrier() __asm__ __volatile__ ("sync" ::: "memory" )
|
||||
#define OPA_read_write_barrier() __asm__ __volatile__ ("sync" ::: "memory" )
|
||||
#define OPA_compiler_barrier() __asm__ __volatile__ ( "" ::: "memory" )
|
||||
|
||||
/* Aligned loads and stores are atomic. */
|
||||
static _opa_inline int OPA_load_int(_opa_const OPA_int_t *ptr)
|
||||
{
|
||||
return ptr->v;
|
||||
}
|
||||
|
||||
/* Aligned loads and stores are atomic. */
|
||||
static _opa_inline void OPA_store_int(OPA_int_t *ptr, int val)
|
||||
{
|
||||
ptr->v = val;
|
||||
}
|
||||
|
||||
/* Aligned loads and stores are atomic. */
|
||||
static _opa_inline void *OPA_load_ptr(_opa_const OPA_ptr_t *ptr)
|
||||
{
|
||||
return ptr->v;
|
||||
}
|
||||
|
||||
/* Aligned loads and stores are atomic. */
|
||||
static _opa_inline void OPA_store_ptr(OPA_ptr_t *ptr, void *val)
|
||||
{
|
||||
ptr->v = val;
|
||||
}
|
||||
|
||||
/* NOTE: these acquire/release operations have not been optimized, I just threw
|
||||
* down a full memory barrier. Spending much time working on the SiCortex platform
|
||||
* doesn't really make a lot of sense since there are so few machines in
|
||||
* existence and no more will ever be built. */
|
||||
static _opa_inline int OPA_load_acquire_int(_opa_const OPA_int_t *ptr)
|
||||
{
|
||||
int tmp;
|
||||
tmp = ptr->v;
|
||||
OPA_read_write_barrier();
|
||||
return tmp;
|
||||
}
|
||||
|
||||
static _opa_inline void OPA_store_release_int(OPA_int_t *ptr, int val)
|
||||
{
|
||||
OPA_read_write_barrier();
|
||||
ptr->v = val;
|
||||
}
|
||||
|
||||
static _opa_inline void *OPA_load_acquire_ptr(_opa_const OPA_ptr_t *ptr)
|
||||
{
|
||||
void *tmp;
|
||||
tmp = ptr->v;
|
||||
OPA_read_write_barrier();
|
||||
return tmp;
|
||||
}
|
||||
|
||||
static _opa_inline void OPA_store_release_ptr(OPA_ptr_t *ptr, void *val)
|
||||
{
|
||||
OPA_read_write_barrier();
|
||||
ptr->v = val;
|
||||
}
|
||||
|
||||
#include <stdint.h>
|
||||
|
||||
/* ICE9 rev A1 chips have a low-frequency bug that causes LL to
|
||||
fail. The workaround is to do the LL twice to make sure the data
|
||||
is in L1
|
||||
|
||||
very few systems are affected
|
||||
|
||||
FIXME We should either remove the workaround entirely or make it
|
||||
configurable/autodetected somehow. [goodell@ 2008/01/06]
|
||||
*/
|
||||
#define ICE9A_LLSC_WAR 0
|
||||
|
||||
/* For a description of the _opa_inline assembly constraints, see the MIPS section of:
|
||||
http://gcc.gnu.org/onlinedocs/gcc-4.3.2/gcc/Machine-Constraints.html#Machine-Constraints
|
||||
|
||||
relevant excerpt:
|
||||
I - A signed 16-bit constant (for arithmetic instructions).
|
||||
J - Integer zero.
|
||||
|
||||
Other _opa_inline asm knowledge worth remembering:
|
||||
r - a general register operand is allowed
|
||||
m - a memory address operand
|
||||
& - earlyclobber; operand is modified before instruction is finished using the input operands
|
||||
= - this operand is write-only
|
||||
|
||||
general format:
|
||||
asm volatile ("instructions" : [outputs] : [inputs] : [clobbered_regs]);
|
||||
"memory" should be included as a clobbered reg for most of these operations.
|
||||
*/
|
||||
|
||||
/* Atomic increment of a 32 bit value, returning the old value */
|
||||
static _opa_inline int OPA_shmemi_fetch_add_4(volatile int * v, int inc)
|
||||
{
|
||||
unsigned long result;
|
||||
if (ICE9A_LLSC_WAR) {
|
||||
unsigned long temp;
|
||||
|
||||
__asm__ __volatile__(
|
||||
" .set mips3 \n"
|
||||
" .set noreorder \n"
|
||||
"1: ll %0, %2 # fetch_add_4 \n"
|
||||
" ll %0, %2 # fetch_add_4 \n"
|
||||
" addu %1, %0, %3 \n"
|
||||
" sc %1, %2 \n"
|
||||
" beqz %1, 1b \n"
|
||||
" nop \n"
|
||||
" .set reorder \n"
|
||||
" .set mips0 \n"
|
||||
: "=&r" (result), "=&r" (temp), "=m" (*v)
|
||||
: "Ir" (inc)
|
||||
: "memory");
|
||||
} else {
|
||||
unsigned long temp;
|
||||
|
||||
__asm__ __volatile__(
|
||||
" .set mips3 \n"
|
||||
" .set noreorder \n"
|
||||
"1: ll %0, %2 # fetch_add_4 \n"
|
||||
" addu %1, %0, %3 \n"
|
||||
" sc %1, %2 \n"
|
||||
" beqz %1, 1b \n"
|
||||
" nop \n"
|
||||
" .set reorder \n"
|
||||
" .set mips0 \n"
|
||||
: "=&r" (result), "=&r" (temp), "=m" (*v)
|
||||
: "Ir" (inc)
|
||||
: "memory");
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
/* Atomic increment of a 64 bit value, returning the old value */
|
||||
static _opa_inline long int OPA_shmemi_fetch_add_8(volatile long int * v, long int inc)
|
||||
{
|
||||
unsigned long result;
|
||||
if (ICE9A_LLSC_WAR) {
|
||||
unsigned long temp;
|
||||
|
||||
__asm__ __volatile__(
|
||||
" .set mips3 \n"
|
||||
" .set noreorder \n"
|
||||
"1: lld %0, %2 # fetch_add_8 \n"
|
||||
" lld %0, %2 # fetch_add_8 \n"
|
||||
" daddu %1, %0, %3 \n"
|
||||
" scd %1, %2 \n"
|
||||
" beqz %1, 1b \n"
|
||||
" nop \n"
|
||||
" .set reorder \n"
|
||||
" .set mips0 \n"
|
||||
: "=&r" (result), "=&r" (temp), "=m" (*v)
|
||||
: "Ir" (inc)
|
||||
: "memory");
|
||||
} else {
|
||||
unsigned long temp;
|
||||
|
||||
__asm__ __volatile__(
|
||||
" .set mips3 \n"
|
||||
" .set noreorder \n"
|
||||
"1: lld %0, %2 # fetch_add_8 \n"
|
||||
" daddu %1, %0, %3 \n"
|
||||
" scd %1, %2 \n"
|
||||
" beqz %1, 1b \n"
|
||||
" nop \n"
|
||||
" .set reorder \n"
|
||||
" .set mips0 \n"
|
||||
: "=&r" (result), "=&r" (temp), "=m" (*v)
|
||||
: "Ir" (inc)
|
||||
: "memory");
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
/* Atomic swap of a 32 bit value, returning the old contents */
|
||||
static _opa_inline int OPA_shmemi_swap_4(volatile int * v, int val)
|
||||
{
|
||||
unsigned long result;
|
||||
if (ICE9A_LLSC_WAR) {
|
||||
unsigned long temp;
|
||||
|
||||
__asm__ __volatile__(
|
||||
" .set mips3 \n"
|
||||
" .set noreorder \n"
|
||||
"1: ll %0, %2 # swap_4 \n"
|
||||
" ll %0, %2 # swap_4 \n"
|
||||
" move %1, %3 \n"
|
||||
" sc %1, %2 \n"
|
||||
" beqz %1, 1b \n"
|
||||
" nop \n"
|
||||
" .set reorder \n"
|
||||
" .set mips0 \n"
|
||||
: "=&r" (result), "=&r" (temp), "=m" (*v)
|
||||
: "r" (val)
|
||||
: "memory");
|
||||
} else {
|
||||
unsigned long temp;
|
||||
|
||||
__asm__ __volatile__(
|
||||
" .set mips3 \n"
|
||||
" .set noreorder \n"
|
||||
"1: ll %0, %2 # swap_4 \n"
|
||||
" move %1, %3 \n"
|
||||
" sc %1, %2 \n"
|
||||
" beqz %1, 1b \n"
|
||||
" nop \n"
|
||||
" .set reorder \n"
|
||||
" .set mips0 \n"
|
||||
: "=&r" (result), "=&r" (temp), "=m" (*v)
|
||||
: "r" (val)
|
||||
: "memory");
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
/* Atomic swap of a 64 bit value, returning the old contents */
|
||||
static _opa_inline long int OPA_shmemi_swap_8(volatile long int * v, long int val)
|
||||
{
|
||||
unsigned long result;
|
||||
if (ICE9A_LLSC_WAR) {
|
||||
unsigned long temp;
|
||||
|
||||
__asm__ __volatile__(
|
||||
" .set mips3 \n"
|
||||
" .set noreorder \n"
|
||||
"1: lld %0, %2 # swap_8 \n"
|
||||
" lld %0, %2 # swap_8 \n"
|
||||
" move %1, %3 \n"
|
||||
" scd %1, %2 \n"
|
||||
" beqz %1, 1b \n"
|
||||
" nop \n"
|
||||
" .set reorder \n"
|
||||
" .set mips0 \n"
|
||||
: "=&r" (result), "=&r" (temp), "=m" (*v)
|
||||
: "r" (val)
|
||||
: "memory");
|
||||
} else {
|
||||
unsigned long temp;
|
||||
|
||||
__asm__ __volatile__(
|
||||
" .set mips3 \n"
|
||||
" .set noreorder \n"
|
||||
"1: lld %0, %2 # swap_8 \n"
|
||||
" move %1, %3 \n"
|
||||
" scd %1, %2 \n"
|
||||
" beqz %1, 1b \n"
|
||||
" nop \n"
|
||||
" .set reorder \n"
|
||||
" .set mips0 \n"
|
||||
: "=&r" (result), "=&r" (temp), "=m" (*v)
|
||||
: "r" (val)
|
||||
: "memory");
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
/* Atomic compare and swap of a 32 bit value, returns the old value
|
||||
* but only does the store of the val value if the old value == expect */
|
||||
static _opa_inline int OPA_shmemi_cswap_4(volatile int * v, int expect, int val)
|
||||
{
|
||||
unsigned long result;
|
||||
if (ICE9A_LLSC_WAR) {
|
||||
unsigned long temp;
|
||||
|
||||
__asm__ __volatile__(
|
||||
" .set mips3 \n"
|
||||
" .set noreorder \n"
|
||||
"1: ll %0, %2 # cswap_4 \n"
|
||||
" ll %0, %2 # cswap_4 \n"
|
||||
" bne %0, %4, 1f \n"
|
||||
" move %1, %3 \n"
|
||||
" sc %1, %2 \n"
|
||||
" beqz %1, 1b \n"
|
||||
" nop \n"
|
||||
" .set reorder \n"
|
||||
"1: \n"
|
||||
" .set mips0 \n"
|
||||
: "=&r" (result), "=&r" (temp), "=m" (*v)
|
||||
: "r" (val), "Jr" (expect)
|
||||
: "memory");
|
||||
} else {
|
||||
unsigned long temp;
|
||||
|
||||
__asm__ __volatile__(
|
||||
" .set mips3 \n"
|
||||
" .set noreorder \n"
|
||||
"1: ll %0, %2 # cswap_4 \n"
|
||||
" bne %0, %4, 1f \n"
|
||||
" move %1, %3 \n"
|
||||
" sc %1, %2 \n"
|
||||
" beqz %1, 1b \n"
|
||||
" nop \n"
|
||||
" .set reorder \n"
|
||||
"1: \n"
|
||||
" .set mips0 \n"
|
||||
: "=&r" (result), "=&r" (temp), "=m" (*v)
|
||||
: "r" (val), "Jr" (expect)
|
||||
: "memory");
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
/* Atomic compare and swap of a 64 bit value, returns the old value
|
||||
* but only does the store of the val value if the old value == expect */
|
||||
static _opa_inline long int OPA_shmemi_cswap_8(volatile long int * v, long int expect, long int val)
|
||||
{
|
||||
unsigned long result;
|
||||
if (ICE9A_LLSC_WAR) {
|
||||
unsigned long temp;
|
||||
|
||||
__asm__ __volatile__(
|
||||
" .set mips3 \n"
|
||||
" .set noreorder \n"
|
||||
"1: lld %0, %2 # cswap_8 \n"
|
||||
" lld %0, %2 # cswap_8 \n"
|
||||
" bne %0, %4, 1f \n"
|
||||
" move %1, %3 \n"
|
||||
" scd %1, %2 \n"
|
||||
" beqz %1, 1b \n"
|
||||
" nop \n"
|
||||
" .set reorder \n"
|
||||
"1: \n"
|
||||
" .set mips0 \n"
|
||||
: "=&r" (result), "=&r" (temp), "=m" (*v)
|
||||
: "r" (val), "Jr" (expect)
|
||||
: "memory");
|
||||
} else {
|
||||
unsigned long temp;
|
||||
|
||||
__asm__ __volatile__(
|
||||
" .set mips3 \n"
|
||||
" .set noreorder \n"
|
||||
"1: lld %0, %2 # cswap_8 \n"
|
||||
" bne %0, %4, 1f \n"
|
||||
" move %1, %3 \n"
|
||||
" scd %1, %2 \n"
|
||||
" beqz %1, 1b \n"
|
||||
" nop \n"
|
||||
" .set reorder \n"
|
||||
"1: \n"
|
||||
" .set mips0 \n"
|
||||
: "=&r" (result), "=&r" (temp), "=m" (*v)
|
||||
: "r" (val), "Jr" (expect)
|
||||
: "memory");
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
static _opa_inline void OPA_add_int(OPA_int_t *ptr, int val)
|
||||
{
|
||||
OPA_shmemi_fetch_add_4(&ptr->v, val);
|
||||
}
|
||||
|
||||
static _opa_inline void *OPA_cas_ptr(OPA_ptr_t *ptr, void *oldv, void *newv)
|
||||
{
|
||||
#if (OPA_SIZEOF_VOID_P == 8)
|
||||
return((int *) OPA_shmemi_cswap_8((volatile long int *) &ptr->v, (uintptr_t) oldv, (uintptr_t) newv));
|
||||
#elif (OPA_SIZEOF_VOID_P == 4)
|
||||
return((int *) OPA_shmemi_cswap_4((volatile int *) &ptr->v, (uintptr_t) oldv, (uintptr_t) newv));
|
||||
#else
|
||||
#error "OPA_SIZEOF_VOID_P has an unexpected value :" OPA_QUOTE(OPA_SIZEOF_VOID_P);
|
||||
#endif
|
||||
}
|
||||
|
||||
static _opa_inline int OPA_cas_int(OPA_int_t *ptr, int oldv, int newv)
|
||||
{
|
||||
return(OPA_shmemi_cswap_4(&ptr->v, oldv, newv));
|
||||
}
|
||||
|
||||
static _opa_inline void OPA_decr_int(OPA_int_t *ptr)
|
||||
{
|
||||
OPA_shmemi_fetch_add_4(&ptr->v, -1);
|
||||
}
|
||||
|
||||
static _opa_inline int OPA_decr_and_test_int(OPA_int_t *ptr)
|
||||
{
|
||||
int old = OPA_shmemi_fetch_add_4(&ptr->v, -1);
|
||||
return (old == 1);
|
||||
}
|
||||
|
||||
static _opa_inline int OPA_fetch_and_add_int(OPA_int_t *ptr, int val)
|
||||
{
|
||||
return(OPA_shmemi_fetch_add_4(&ptr->v, val));
|
||||
}
|
||||
|
||||
static _opa_inline int OPA_fetch_and_decr_int(OPA_int_t *ptr)
|
||||
{
|
||||
return(OPA_shmemi_fetch_add_4(&ptr->v, -1));
|
||||
}
|
||||
|
||||
static _opa_inline int OPA_fetch_and_incr_int(OPA_int_t *ptr)
|
||||
{
|
||||
return(OPA_shmemi_fetch_add_4(&ptr->v, 1));
|
||||
}
|
||||
|
||||
static _opa_inline void OPA_incr_int(OPA_int_t *ptr)
|
||||
{
|
||||
OPA_shmemi_fetch_add_4(&ptr->v, 1);
|
||||
}
|
||||
|
||||
static _opa_inline int *OPA_swap_ptr(OPA_ptr_t *ptr, int *val)
|
||||
{
|
||||
#if (OPA_SIZEOF_VOID_P == 8)
|
||||
return((int *) OPA_shmemi_swap_8((volatile long int *) &ptr->v, (uintptr_t) val));
|
||||
#elif (OPA_SIZEOF_VOID_P == 4)
|
||||
return((int *) OPA_shmemi_swap_4((volatile int *) &ptr->v, (uintptr_t) val));
|
||||
#else
|
||||
#error "OPA_SIZEOF_VOID_P has an unexpected value :" OPA_QUOTE(OPA_SIZEOF_VOID_P);
|
||||
#endif
|
||||
}
|
||||
|
||||
static _opa_inline int OPA_swap_int(OPA_int_t *ptr, int val)
|
||||
{
|
||||
return(OPA_shmemi_swap_4(&ptr->v, val));
|
||||
}
|
||||
|
||||
#endif /* OPA_GCC_SICORTEX_H */
|
||||
@@ -1,154 +0,0 @@
|
||||
/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */
|
||||
/*
|
||||
* (C) 2008 by Argonne National Laboratory.
|
||||
* See COPYRIGHT in top-level directory.
|
||||
*/
|
||||
|
||||
#ifndef OPA_NT_INTRINSICS_H_INCLUDED
|
||||
#define OPA_NT_INTRINSICS_H_INCLUDED
|
||||
|
||||
#define WIN32_LEAN_AND_MEAN
|
||||
#include<windows.h>
|
||||
#include<intrin.h>
|
||||
#include "mpi.h"
|
||||
|
||||
/* OPA_int_t uses a long because the compiler intrinsics operate on
|
||||
* longs instead of ints. */
|
||||
typedef struct { volatile long v; } OPA_int_t;
|
||||
typedef struct { void * volatile v; } OPA_ptr_t;
|
||||
|
||||
#define OPA_INT_T_INITIALIZER(val_) { (val_) }
|
||||
#define OPA_PTR_T_INITIALIZER(val_) { (val_) }
|
||||
|
||||
#define OPA_write_barrier() _WriteBarrier()
|
||||
#define OPA_read_barrier() _ReadBarrier()
|
||||
#define OPA_read_write_barrier() _ReadWriteBarrier()
|
||||
/* FIXME there mut be a more efficient way to implement this. Is "asm {};"
|
||||
* sufficient? */
|
||||
#define OPA_compiler_barrier() _ReadWriteBarrier()
|
||||
|
||||
static _opa_inline int OPA_load_int(_opa_const OPA_int_t *ptr)
|
||||
{
|
||||
return ((int)ptr->v);
|
||||
}
|
||||
|
||||
static _opa_inline void OPA_store_int(OPA_int_t *ptr, int val)
|
||||
{
|
||||
ptr->v = (long)val;
|
||||
}
|
||||
|
||||
static _opa_inline void *OPA_load_ptr(_opa_const OPA_ptr_t *ptr)
|
||||
{
|
||||
return ((void *)ptr->v);
|
||||
}
|
||||
|
||||
static _opa_inline void OPA_store_ptr(OPA_ptr_t *ptr, void *val)
|
||||
{
|
||||
ptr->v = val;
|
||||
}
|
||||
|
||||
/* NOTE: these acquire/release operations have not been optimized, I just threw
|
||||
* down a full memory barrier. Someone with more Windows expertise should feel
|
||||
* free to improve these (for Windows on x86/x86_64 these almost certainly only
|
||||
* need to be compiler barriers). */
|
||||
static _opa_inline int OPA_load_acquire_int(_opa_const OPA_int_t *ptr)
|
||||
{
|
||||
int tmp;
|
||||
tmp = ptr->v;
|
||||
OPA_read_write_barrier();
|
||||
return tmp;
|
||||
}
|
||||
|
||||
static _opa_inline void OPA_store_release_int(OPA_int_t *ptr, int val)
|
||||
{
|
||||
OPA_read_write_barrier();
|
||||
ptr->v = val;
|
||||
}
|
||||
|
||||
static _opa_inline void *OPA_load_acquire_ptr(_opa_const OPA_ptr_t *ptr)
|
||||
{
|
||||
void *tmp;
|
||||
tmp = ptr->v;
|
||||
OPA_read_write_barrier();
|
||||
return tmp;
|
||||
}
|
||||
|
||||
static _opa_inline void OPA_store_release_ptr(OPA_ptr_t *ptr, void *val)
|
||||
{
|
||||
OPA_read_write_barrier();
|
||||
ptr->v = val;
|
||||
}
|
||||
|
||||
|
||||
static _opa_inline void OPA_add_int(OPA_int_t *ptr, int val)
|
||||
{
|
||||
_InterlockedExchangeAdd(&(ptr->v), val);
|
||||
}
|
||||
|
||||
static _opa_inline void OPA_incr_int(OPA_int_t *ptr)
|
||||
{
|
||||
_InterlockedIncrement(&(ptr->v));
|
||||
}
|
||||
|
||||
static _opa_inline void OPA_decr_int(OPA_int_t *ptr)
|
||||
{
|
||||
_InterlockedDecrement(&(ptr->v));
|
||||
}
|
||||
|
||||
static _opa_inline int OPA_decr_and_test_int(OPA_int_t *ptr)
|
||||
{
|
||||
return (_InterlockedDecrement(&(ptr->v)) == 0);
|
||||
}
|
||||
|
||||
static _opa_inline int OPA_fetch_and_add_int(OPA_int_t *ptr, int val)
|
||||
{
|
||||
return ((int)_InterlockedExchangeAdd(&(ptr->v), (long)val));
|
||||
}
|
||||
|
||||
static _opa_inline void *OPA_cas_ptr(OPA_ptr_t *ptr, void *oldv, void *newv)
|
||||
{
|
||||
#if (OPA_SIZEOF_VOID_P == 4)
|
||||
return ((void *)(LONG_PTR) _InterlockedCompareExchange((LONG volatile *)&(ptr->v),
|
||||
(LONG)(LONG_PTR)newv,
|
||||
(LONG)(LONG_PTR)oldv)
|
||||
);
|
||||
#elif (OPA_SIZEOF_VOID_P == 8)
|
||||
return ((void *)(LONG_PTR)_InterlockedCompareExchange64((__int64 *)&(ptr->v),
|
||||
(INT64)(LONG_PTR)newv,
|
||||
(INT64)(LONG_PTR)oldv)
|
||||
);
|
||||
#else
|
||||
#error "OPA_SIZEOF_VOID_P not valid"
|
||||
#endif
|
||||
}
|
||||
|
||||
static _opa_inline void *OPA_swap_ptr(OPA_ptr_t *ptr, void *val)
|
||||
{
|
||||
#if (OPA_SIZEOF_VOID_P == 4)
|
||||
return (void *)(LONG_PTR )_InterlockedExchange((LONG volatile *)&(ptr->v),
|
||||
(LONG)(LONG_PTR)val);
|
||||
#elif (OPA_SIZEOF_VOID_P == 8)
|
||||
return (void *)(LONG_PTR)_InterlockedExchange64((LONG64 volatile *)&(ptr->v),
|
||||
(INT64)(LONG_PTR)val);
|
||||
#else
|
||||
#error "OPA_SIZEOF_VOID_P not valid"
|
||||
#endif
|
||||
}
|
||||
|
||||
static _opa_inline int OPA_cas_int(OPA_int_t *ptr, int oldv, int newv)
|
||||
{
|
||||
return _InterlockedCompareExchange((long *)&(ptr->v), newv, oldv);
|
||||
}
|
||||
|
||||
static _opa_inline int OPA_swap_int(OPA_int_t *ptr, int val)
|
||||
{
|
||||
return _InterlockedExchange(&(ptr->v), val);
|
||||
}
|
||||
|
||||
/* Implement fetch_and_incr/decr using fetch_and_add (*_faa) */
|
||||
#define OPA_fetch_and_incr_int_by_faa OPA_fetch_and_incr_int
|
||||
#define OPA_fetch_and_decr_int_by_faa OPA_fetch_and_decr_int
|
||||
|
||||
#include "opa_emulated.h"
|
||||
|
||||
#endif /* defined(OPA_NT_INTRINSICS_H_INCLUDED) */
|
||||
@@ -1,135 +0,0 @@
|
||||
/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */
|
||||
/*
|
||||
* (C) 2008 by Argonne National Laboratory.
|
||||
* See COPYRIGHT in top-level directory.
|
||||
*/
|
||||
|
||||
|
||||
#ifndef OPA_SUN_ATOMIC_OPS_H_INCLUDED
|
||||
#define OPA_SUN_ATOMIC_OPS_H_INCLUDED
|
||||
|
||||
#include <atomic.h>
|
||||
|
||||
typedef struct { volatile uint_t v; } OPA_int_t;
|
||||
typedef struct { void * volatile v; } OPA_ptr_t;
|
||||
|
||||
#define OPA_INT_T_INITIALIZER(val_) { (val_) }
|
||||
#define OPA_PTR_T_INITIALIZER(val_) { (val_) }
|
||||
|
||||
static _opa_inline int OPA_load_int(_opa_const OPA_int_t *ptr)
|
||||
{
|
||||
return (int)ptr->v;
|
||||
}
|
||||
|
||||
static _opa_inline void OPA_store_int(OPA_int_t *ptr, int val)
|
||||
{
|
||||
ptr->v = (uint)val;
|
||||
}
|
||||
|
||||
static _opa_inline void *OPA_load_ptr(_opa_const OPA_ptr_t *ptr)
|
||||
{
|
||||
return ptr->v;
|
||||
}
|
||||
|
||||
static _opa_inline void OPA_store_ptr(OPA_ptr_t *ptr, void *val)
|
||||
{
|
||||
ptr->v = val;
|
||||
}
|
||||
|
||||
static _opa_inline int OPA_load_acquire_int(_opa_const OPA_int_t *ptr)
|
||||
{
|
||||
int tmp;
|
||||
tmp = ptr->v;
|
||||
membar_enter();
|
||||
return tmp;
|
||||
}
|
||||
|
||||
static _opa_inline void OPA_store_release_int(OPA_int_t *ptr, int val)
|
||||
{
|
||||
membar_exit();
|
||||
ptr->v = val;
|
||||
}
|
||||
|
||||
static _opa_inline void *OPA_load_acquire_ptr(_opa_const OPA_ptr_t *ptr)
|
||||
{
|
||||
void *tmp;
|
||||
tmp = ptr->v;
|
||||
membar_enter();
|
||||
return tmp;
|
||||
}
|
||||
|
||||
static _opa_inline void OPA_store_release_ptr(OPA_ptr_t *ptr, void *val)
|
||||
{
|
||||
membar_exit();
|
||||
ptr->v = val;
|
||||
}
|
||||
|
||||
|
||||
static _opa_inline void OPA_add_int(OPA_int_t *ptr, int val)
|
||||
{
|
||||
atomic_add_int(&ptr->v, val);
|
||||
}
|
||||
|
||||
static _opa_inline void OPA_incr_int(OPA_int_t *ptr)
|
||||
{
|
||||
atomic_inc_uint(&ptr->v);
|
||||
}
|
||||
|
||||
static _opa_inline void OPA_decr_int(OPA_int_t *ptr)
|
||||
{
|
||||
atomic_dec_uint(&ptr->v);
|
||||
}
|
||||
|
||||
|
||||
static _opa_inline int OPA_decr_and_test_int(OPA_int_t *ptr)
|
||||
{
|
||||
return atomic_dec_uint_nv(&ptr->v) == 0;
|
||||
}
|
||||
|
||||
|
||||
static _opa_inline int OPA_fetch_and_add_int(OPA_int_t *ptr, int val)
|
||||
{
|
||||
return (int)atomic_add_int_nv(&ptr->v, val) - val;
|
||||
}
|
||||
|
||||
static _opa_inline int OPA_fetch_and_decr_int(OPA_int_t *ptr)
|
||||
{
|
||||
return (int)atomic_dec_uint_nv(&ptr->v) + 1;
|
||||
}
|
||||
|
||||
static _opa_inline int OPA_fetch_and_incr_int(OPA_int_t *ptr)
|
||||
{
|
||||
return (int)atomic_inc_uint_nv(&ptr->v) - 1;
|
||||
}
|
||||
|
||||
|
||||
static _opa_inline void *OPA_cas_ptr(OPA_ptr_t *ptr, void *oldv, void *newv)
|
||||
{
|
||||
return atomic_cas_ptr(ptr, oldv, newv);
|
||||
}
|
||||
|
||||
static _opa_inline int OPA_cas_int(OPA_int_t *ptr, int oldv, int newv)
|
||||
{
|
||||
return (int)atomic_cas_uint(&ptr->v, (uint_t)oldv, (uint_t)newv);
|
||||
}
|
||||
|
||||
|
||||
static _opa_inline void *OPA_swap_ptr(OPA_ptr_t *ptr, void *val)
|
||||
{
|
||||
return atomic_swap_ptr(ptr, val);
|
||||
}
|
||||
|
||||
static _opa_inline int OPA_swap_int(OPA_int_t *ptr, int val)
|
||||
{
|
||||
return (int)atomic_swap_uint(&ptr->v, (uint_t) val);
|
||||
}
|
||||
|
||||
|
||||
#define OPA_write_barrier() membar_producer()
|
||||
#define OPA_read_barrier() membar_consumer()
|
||||
#define OPA_read_write_barrier() do { membar_consumer(); membar_producer(); } while (0)
|
||||
|
||||
/* is this portable enough? */
|
||||
#define OPA_compiler_barrier() __asm__ __volatile__ ( "" ::: "memory" )
|
||||
|
||||
#endif /* OPA_SUN_ATOMIC_OPS_H_INCLUDED */
|
||||
@@ -1,152 +0,0 @@
|
||||
/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */
|
||||
/*
|
||||
* (C) 2008 by Argonne National Laboratory.
|
||||
* See COPYRIGHT in top-level directory.
|
||||
*/
|
||||
|
||||
#ifndef OPA_UNSAFE_H_INCLUDED
|
||||
#define OPA_UNSAFE_H_INCLUDED
|
||||
|
||||
/* NOTE: These types intentionally do not use volatile in order to provide even
|
||||
* better performance. If a good use case for having unsafe operations with
|
||||
* volatile types comes up, we can make two definitions that are conditional on
|
||||
* something sort of like NDEBUG. [goodell@ 2009-08-18] */
|
||||
typedef struct { int v; } OPA_int_t;
|
||||
typedef struct { int *v; } OPA_ptr_t;
|
||||
|
||||
#define OPA_INT_T_INITIALIZER(val_) { (val_) }
|
||||
#define OPA_PTR_T_INITIALIZER(val_) { (val_) }
|
||||
|
||||
/*
|
||||
Unsafe Primitives
|
||||
-----------------
|
||||
|
||||
These are versions of the atomic primitives that emulate the single-threaded
|
||||
behavior of the primitives but do not attempt to provide any safety against
|
||||
concurrent use. The primary use case for this implementation is to avoid
|
||||
overhead without code changes in client libraries and applications that have
|
||||
been compiled for single-threaded use only. They might also be useful for
|
||||
testing (and testing of tests) in some cases.
|
||||
|
||||
Thanks to Josh Haberman for inspiring this primitives implementation.
|
||||
*/
|
||||
|
||||
static _opa_inline int OPA_load_int(const OPA_int_t *ptr)
|
||||
{
|
||||
int retval;
|
||||
retval = ptr->v;
|
||||
return retval;
|
||||
}
|
||||
|
||||
static _opa_inline void OPA_store_int(OPA_int_t *ptr, int val)
|
||||
{
|
||||
ptr->v = val;
|
||||
}
|
||||
|
||||
static _opa_inline void *OPA_load_ptr(const OPA_ptr_t *ptr)
|
||||
{
|
||||
int *retval;
|
||||
retval = ptr->v;
|
||||
return retval;
|
||||
}
|
||||
|
||||
static _opa_inline void OPA_store_ptr(OPA_ptr_t *ptr, void *val)
|
||||
{
|
||||
ptr->v = val;
|
||||
}
|
||||
|
||||
/* no barrier needed, not even a compiler barrier */
|
||||
#define OPA_load_acquire_int(ptr_) OPA_load_int((ptr_))
|
||||
#define OPA_store_release_int(ptr_,val_) OPA_store_int((ptr_),(val_))
|
||||
#define OPA_load_acquire_ptr(ptr_) OPA_load_ptr((ptr_))
|
||||
#define OPA_store_release_ptr(ptr_,val_) OPA_store_ptr((ptr_),(val_))
|
||||
|
||||
static _opa_inline void OPA_add_int(OPA_int_t *ptr, int val)
|
||||
{
|
||||
ptr->v += val;
|
||||
}
|
||||
|
||||
static _opa_inline void *OPA_cas_ptr(OPA_ptr_t *ptr, int *oldv, int *newv)
|
||||
{
|
||||
int *prev;
|
||||
prev = ptr->v;
|
||||
if (prev == oldv) {
|
||||
ptr->v = newv;
|
||||
}
|
||||
return prev;
|
||||
}
|
||||
|
||||
static _opa_inline int OPA_cas_int(OPA_int_t *ptr, int oldv, int newv)
|
||||
{
|
||||
int prev;
|
||||
prev = ptr->v;
|
||||
if (prev == oldv) {
|
||||
ptr->v = newv;
|
||||
}
|
||||
return prev;
|
||||
}
|
||||
|
||||
static _opa_inline int OPA_decr_and_test_int(OPA_int_t *ptr)
|
||||
{
|
||||
int new_val;
|
||||
new_val = --(ptr->v);
|
||||
return (0 == new_val);
|
||||
}
|
||||
|
||||
static _opa_inline void OPA_decr_int(OPA_int_t *ptr)
|
||||
{
|
||||
--(ptr->v);
|
||||
}
|
||||
|
||||
static _opa_inline int OPA_fetch_and_add_int(OPA_int_t *ptr, int val)
|
||||
{
|
||||
int prev;
|
||||
prev = ptr->v;
|
||||
ptr->v += val;
|
||||
return prev;
|
||||
}
|
||||
|
||||
static _opa_inline int OPA_fetch_and_decr_int(OPA_int_t *ptr)
|
||||
{
|
||||
int prev;
|
||||
prev = ptr->v;
|
||||
--(ptr->v);
|
||||
return prev;
|
||||
}
|
||||
|
||||
static _opa_inline int OPA_fetch_and_incr_int(OPA_int_t *ptr)
|
||||
{
|
||||
int prev;
|
||||
prev = ptr->v;
|
||||
++(ptr->v);
|
||||
return prev;
|
||||
}
|
||||
|
||||
static _opa_inline void OPA_incr_int(OPA_int_t *ptr)
|
||||
{
|
||||
++(ptr->v);
|
||||
}
|
||||
|
||||
static _opa_inline void *OPA_swap_ptr(OPA_ptr_t *ptr, void *val)
|
||||
{
|
||||
int *prev;
|
||||
prev = ptr->v;
|
||||
ptr->v = val;
|
||||
return prev;
|
||||
}
|
||||
|
||||
static _opa_inline int OPA_swap_int(OPA_int_t *ptr, int val)
|
||||
{
|
||||
int prev;
|
||||
prev = ptr->v;
|
||||
ptr->v = val;
|
||||
return (int)prev;
|
||||
}
|
||||
|
||||
/* null barriers */
|
||||
#define OPA_write_barrier() do {} while (0)
|
||||
#define OPA_read_barrier() do {} while (0)
|
||||
#define OPA_read_write_barrier() do {} while (0)
|
||||
#define OPA_compiler_barrier() do {} while (0)
|
||||
|
||||
#endif /* !defined(OPA_UNSAFE_H_INCLUDED) */
|
||||
Binary file not shown.
@@ -1,5 +1,5 @@
|
||||
# libmpi.la - a libtool library file
|
||||
# Generated by libtool (GNU libtool) 2.4.6 Debian-2.4.6-2
|
||||
# Generated by libtool (GNU libtool) 2.4.6
|
||||
#
|
||||
# Please DO NOT delete this file!
|
||||
# It is necessary for linking the library.
|
||||
@@ -8,7 +8,7 @@
|
||||
dlname='libmpi.so.12'
|
||||
|
||||
# Names of this library.
|
||||
library_names='libmpi.so.12.1.1 libmpi.so.12 libmpi.so'
|
||||
library_names='libmpi.so.12.1.7 libmpi.so.12 libmpi.so'
|
||||
|
||||
# The name of the static archive.
|
||||
old_library='libmpi.a'
|
||||
@@ -17,7 +17,7 @@ old_library='libmpi.a'
|
||||
inherited_linker_flags=''
|
||||
|
||||
# Libraries that this one depends upon.
|
||||
dependency_libs=' -L/home/brgirgis/Documents/code/thirdparty/mpi/mpich_/build/src/mpl -lrt -lpthread'
|
||||
dependency_libs=' -lm -lpthread -lrt'
|
||||
|
||||
# Names of additional weak libraries provided by this library
|
||||
weak_library_names=''
|
||||
@@ -25,7 +25,7 @@ weak_library_names=''
|
||||
# Version information for libmpi.
|
||||
current=13
|
||||
age=1
|
||||
revision=1
|
||||
revision=7
|
||||
|
||||
# Is this an already installed library?
|
||||
installed=yes
|
||||
@@ -38,4 +38,4 @@ dlopen=''
|
||||
dlpreopen=''
|
||||
|
||||
# Directory that this library needs to be installed in:
|
||||
libdir='/home/brgirgis/Documents/code/thirdparty/mpi/mpich_/build/../release_install/lib64'
|
||||
libdir='/home/brgirgis/Documents/code/idiscovery/cpp-thirdparty-src/mpi/mpich/install/3.3.1/lib64'
|
||||
|
||||
@@ -1 +1 @@
|
||||
libmpi.so.12.1.1
|
||||
libmpi.so.12.1.7
|
||||
@@ -1 +1 @@
|
||||
libmpi.so.12.1.1
|
||||
libmpi.so.12.1.7
|
||||
Binary file not shown.
BIN
linx64/mpi/mpich/lib64/libmpi.so.12.1.7
Executable file
BIN
linx64/mpi/mpich/lib64/libmpi.so.12.1.7
Executable file
Binary file not shown.
@@ -1,15 +1,15 @@
|
||||
# this gives access to the mpich header files
|
||||
prefix=/home/brgirgis/Documents/code/thirdparty/mpi/mpich_/build/../release_install
|
||||
prefix=/home/brgirgis/Documents/code/idiscovery/cpp-thirdparty-src/mpi/mpich/install/3.3.1
|
||||
exec_prefix=${prefix}
|
||||
libdir=${exec_prefix}/lib64
|
||||
includedir=${prefix}/include
|
||||
|
||||
Name: mpich
|
||||
Description: High Performance and portable MPI
|
||||
Version: 3.2.1
|
||||
Version: 3.3.1
|
||||
URL: http://www.mcs.anl.gov/research/projects/mpich
|
||||
Requires:
|
||||
Libs: -Wl,-rpath -Wl,${exec_prefix}/lib64 -L${libdir} -lmpi -lrt -lpthread
|
||||
Libs: -Wl,-rpath -Wl,${exec_prefix}/lib64 -L${libdir} -lmpi -lm -lpthread -lrt
|
||||
Cflags: -I${includedir}
|
||||
|
||||
# pkg-config does not understand Cxxflags, etc. So we allow users to
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
prefix=/home/brgirgis/Documents/code/thirdparty/mpi/mpich_/build/../release_install
|
||||
prefix=/home/brgirgis/Documents/code/idiscovery/cpp-thirdparty-src/mpi/mpich/install/3.3.1
|
||||
exec_prefix=${prefix}
|
||||
libdir=${exec_prefix}/lib64
|
||||
includedir=${prefix}/include
|
||||
|
||||
@@ -19,533 +19,545 @@
|
||||
<H2>MPI Routines and Constants</H2>
|
||||
<TABLE>
|
||||
<TR><TD><A HREF="www3/Constants.html">Constants</A></TD>
|
||||
<TD><A HREF="www3/MPI_File_set_atomicity.html">MPI_File_set_atomicity</A></TD>
|
||||
<TD><A HREF="www3/MPI_File_read_ordered_end.html">MPI_File_read_ordered_end</A></TD>
|
||||
<TD><A HREF="www3/MPI_Rget_accumulate.html">MPI_Rget_accumulate</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPIR_Type_commit.html">MPIR_Type_commit</A></TD>
|
||||
<TD><A HREF="www3/MPI_File_read_shared.html">MPI_File_read_shared</A></TD>
|
||||
<TD><A HREF="www3/MPI_Rput.html">MPI_Rput</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPIX_Comm_agree.html">MPIX_Comm_agree</A></TD>
|
||||
<TD><A HREF="www3/MPI_File_set_errhandler.html">MPI_File_set_errhandler</A></TD>
|
||||
<TR><TD><A HREF="www3/MPIR_Type_contiguous.html">MPIR_Type_contiguous</A></TD>
|
||||
<TD><A HREF="www3/MPI_File_seek.html">MPI_File_seek</A></TD>
|
||||
<TD><A HREF="www3/MPI_Rsend.html">MPI_Rsend</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPIX_Comm_failure_ack.html">MPIX_Comm_failure_ack</A></TD>
|
||||
<TD><A HREF="www3/MPI_File_set_info.html">MPI_File_set_info</A></TD>
|
||||
<TR><TD><A HREF="www3/MPIR_Type_dup.html">MPIR_Type_dup</A></TD>
|
||||
<TD><A HREF="www3/MPI_File_seek_shared.html">MPI_File_seek_shared</A></TD>
|
||||
<TD><A HREF="www3/MPI_Rsend_init.html">MPI_Rsend_init</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPIX_Comm_failure_get_acked.html">MPIX_Comm_failure_get_acked</A></TD>
|
||||
<TD><A HREF="www3/MPI_File_set_size.html">MPI_File_set_size</A></TD>
|
||||
<TR><TD><A HREF="www3/MPIR_Type_get_contents.html">MPIR_Type_get_contents</A></TD>
|
||||
<TD><A HREF="www3/MPI_File_set_atomicity.html">MPI_File_set_atomicity</A></TD>
|
||||
<TD><A HREF="www3/MPI_Scan.html">MPI_Scan</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPIX_Comm_revoke.html">MPIX_Comm_revoke</A></TD>
|
||||
<TD><A HREF="www3/MPI_File_set_view.html">MPI_File_set_view</A></TD>
|
||||
<TR><TD><A HREF="www3/MPIR_Type_indexed.html">MPIR_Type_indexed</A></TD>
|
||||
<TD><A HREF="www3/MPI_File_set_errhandler.html">MPI_File_set_errhandler</A></TD>
|
||||
<TD><A HREF="www3/MPI_Scatter.html">MPI_Scatter</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPIX_Comm_shrink.html">MPIX_Comm_shrink</A></TD>
|
||||
<TD><A HREF="www3/MPI_File_sync.html">MPI_File_sync</A></TD>
|
||||
<TR><TD><A HREF="www3/MPIR_Type_struct.html">MPIR_Type_struct</A></TD>
|
||||
<TD><A HREF="www3/MPI_File_set_info.html">MPI_File_set_info</A></TD>
|
||||
<TD><A HREF="www3/MPI_Scatterv.html">MPI_Scatterv</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Abort.html">MPI_Abort</A></TD>
|
||||
<TD><A HREF="www3/MPI_File_write.html">MPI_File_write</A></TD>
|
||||
<TR><TD><A HREF="www3/MPIR_Type_vector.html">MPIR_Type_vector</A></TD>
|
||||
<TD><A HREF="www3/MPI_File_set_size.html">MPI_File_set_size</A></TD>
|
||||
<TD><A HREF="www3/MPI_Send.html">MPI_Send</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Accumulate.html">MPI_Accumulate</A></TD>
|
||||
<TD><A HREF="www3/MPI_File_write_all.html">MPI_File_write_all</A></TD>
|
||||
<TR><TD><A HREF="www3/MPIX_Comm_agree.html">MPIX_Comm_agree</A></TD>
|
||||
<TD><A HREF="www3/MPI_File_set_view.html">MPI_File_set_view</A></TD>
|
||||
<TD><A HREF="www3/MPI_Send_init.html">MPI_Send_init</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Add_error_class.html">MPI_Add_error_class</A></TD>
|
||||
<TD><A HREF="www3/MPI_File_write_all_begin.html">MPI_File_write_all_begin</A></TD>
|
||||
<TR><TD><A HREF="www3/MPIX_Comm_failure_ack.html">MPIX_Comm_failure_ack</A></TD>
|
||||
<TD><A HREF="www3/MPI_File_sync.html">MPI_File_sync</A></TD>
|
||||
<TD><A HREF="www3/MPI_Sendrecv.html">MPI_Sendrecv</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Add_error_code.html">MPI_Add_error_code</A></TD>
|
||||
<TD><A HREF="www3/MPI_File_write_all_end.html">MPI_File_write_all_end</A></TD>
|
||||
<TR><TD><A HREF="www3/MPIX_Comm_failure_get_acked.html">MPIX_Comm_failure_get_acked</A></TD>
|
||||
<TD><A HREF="www3/MPI_File_write.html">MPI_File_write</A></TD>
|
||||
<TD><A HREF="www3/MPI_Sendrecv_replace.html">MPI_Sendrecv_replace</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Add_error_string.html">MPI_Add_error_string</A></TD>
|
||||
<TD><A HREF="www3/MPI_File_write_at.html">MPI_File_write_at</A></TD>
|
||||
<TR><TD><A HREF="www3/MPIX_Comm_revoke.html">MPIX_Comm_revoke</A></TD>
|
||||
<TD><A HREF="www3/MPI_File_write_all.html">MPI_File_write_all</A></TD>
|
||||
<TD><A HREF="www3/MPI_Ssend.html">MPI_Ssend</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Address.html">MPI_Address</A></TD>
|
||||
<TD><A HREF="www3/MPI_File_write_at_all.html">MPI_File_write_at_all</A></TD>
|
||||
<TR><TD><A HREF="www3/MPIX_Comm_shrink.html">MPIX_Comm_shrink</A></TD>
|
||||
<TD><A HREF="www3/MPI_File_write_all_begin.html">MPI_File_write_all_begin</A></TD>
|
||||
<TD><A HREF="www3/MPI_Ssend_init.html">MPI_Ssend_init</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Aint_add.html">MPI_Aint_add</A></TD>
|
||||
<TD><A HREF="www3/MPI_File_write_at_all_begin.html">MPI_File_write_at_all_begin</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Abort.html">MPI_Abort</A></TD>
|
||||
<TD><A HREF="www3/MPI_File_write_all_end.html">MPI_File_write_all_end</A></TD>
|
||||
<TD><A HREF="www3/MPI_Start.html">MPI_Start</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Aint_diff.html">MPI_Aint_diff</A></TD>
|
||||
<TD><A HREF="www3/MPI_File_write_at_all_end.html">MPI_File_write_at_all_end</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Accumulate.html">MPI_Accumulate</A></TD>
|
||||
<TD><A HREF="www3/MPI_File_write_at.html">MPI_File_write_at</A></TD>
|
||||
<TD><A HREF="www3/MPI_Startall.html">MPI_Startall</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Allgather.html">MPI_Allgather</A></TD>
|
||||
<TD><A HREF="www3/MPI_File_write_ordered.html">MPI_File_write_ordered</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Add_error_class.html">MPI_Add_error_class</A></TD>
|
||||
<TD><A HREF="www3/MPI_File_write_at_all.html">MPI_File_write_at_all</A></TD>
|
||||
<TD><A HREF="www3/MPI_Status_set_cancelled.html">MPI_Status_set_cancelled</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Allgatherv.html">MPI_Allgatherv</A></TD>
|
||||
<TD><A HREF="www3/MPI_File_write_ordered_begin.html">MPI_File_write_ordered_begin</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Add_error_code.html">MPI_Add_error_code</A></TD>
|
||||
<TD><A HREF="www3/MPI_File_write_at_all_begin.html">MPI_File_write_at_all_begin</A></TD>
|
||||
<TD><A HREF="www3/MPI_Status_set_elements.html">MPI_Status_set_elements</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Alloc_mem.html">MPI_Alloc_mem</A></TD>
|
||||
<TD><A HREF="www3/MPI_File_write_ordered_end.html">MPI_File_write_ordered_end</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Add_error_string.html">MPI_Add_error_string</A></TD>
|
||||
<TD><A HREF="www3/MPI_File_write_at_all_end.html">MPI_File_write_at_all_end</A></TD>
|
||||
<TD><A HREF="www3/MPI_Status_set_elements_x.html">MPI_Status_set_elements_x</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Allreduce.html">MPI_Allreduce</A></TD>
|
||||
<TD><A HREF="www3/MPI_File_write_shared.html">MPI_File_write_shared</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Address.html">MPI_Address</A></TD>
|
||||
<TD><A HREF="www3/MPI_File_write_ordered.html">MPI_File_write_ordered</A></TD>
|
||||
<TD><A HREF="www3/MPI_T_category_changed.html">MPI_T_category_changed</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Alltoall.html">MPI_Alltoall</A></TD>
|
||||
<TD><A HREF="www3/MPI_Finalize.html">MPI_Finalize</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Aint_add.html">MPI_Aint_add</A></TD>
|
||||
<TD><A HREF="www3/MPI_File_write_ordered_begin.html">MPI_File_write_ordered_begin</A></TD>
|
||||
<TD><A HREF="www3/MPI_T_category_get_categories.html">MPI_T_category_get_categories</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Alltoallv.html">MPI_Alltoallv</A></TD>
|
||||
<TD><A HREF="www3/MPI_Finalized.html">MPI_Finalized</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Aint_diff.html">MPI_Aint_diff</A></TD>
|
||||
<TD><A HREF="www3/MPI_File_write_ordered_end.html">MPI_File_write_ordered_end</A></TD>
|
||||
<TD><A HREF="www3/MPI_T_category_get_cvars.html">MPI_T_category_get_cvars</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Alltoallw.html">MPI_Alltoallw</A></TD>
|
||||
<TD><A HREF="www3/MPI_Free_mem.html">MPI_Free_mem</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Allgather.html">MPI_Allgather</A></TD>
|
||||
<TD><A HREF="www3/MPI_File_write_shared.html">MPI_File_write_shared</A></TD>
|
||||
<TD><A HREF="www3/MPI_T_category_get_info.html">MPI_T_category_get_info</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Attr_delete.html">MPI_Attr_delete</A></TD>
|
||||
<TD><A HREF="www3/MPI_Gather.html">MPI_Gather</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Allgatherv.html">MPI_Allgatherv</A></TD>
|
||||
<TD><A HREF="www3/MPI_Finalize.html">MPI_Finalize</A></TD>
|
||||
<TD><A HREF="www3/MPI_T_category_get_num.html">MPI_T_category_get_num</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Attr_get.html">MPI_Attr_get</A></TD>
|
||||
<TD><A HREF="www3/MPI_Gatherv.html">MPI_Gatherv</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Alloc_mem.html">MPI_Alloc_mem</A></TD>
|
||||
<TD><A HREF="www3/MPI_Finalized.html">MPI_Finalized</A></TD>
|
||||
<TD><A HREF="www3/MPI_T_category_get_pvars.html">MPI_T_category_get_pvars</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Attr_put.html">MPI_Attr_put</A></TD>
|
||||
<TD><A HREF="www3/MPI_Get.html">MPI_Get</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Allreduce.html">MPI_Allreduce</A></TD>
|
||||
<TD><A HREF="www3/MPI_Free_mem.html">MPI_Free_mem</A></TD>
|
||||
<TD><A HREF="www3/MPI_T_cvar_get_info.html">MPI_T_cvar_get_info</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Barrier.html">MPI_Barrier</A></TD>
|
||||
<TD><A HREF="www3/MPI_Get_accumulate.html">MPI_Get_accumulate</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Alltoall.html">MPI_Alltoall</A></TD>
|
||||
<TD><A HREF="www3/MPI_Gather.html">MPI_Gather</A></TD>
|
||||
<TD><A HREF="www3/MPI_T_cvar_get_num.html">MPI_T_cvar_get_num</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Bcast.html">MPI_Bcast</A></TD>
|
||||
<TD><A HREF="www3/MPI_Get_address.html">MPI_Get_address</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Alltoallv.html">MPI_Alltoallv</A></TD>
|
||||
<TD><A HREF="www3/MPI_Gatherv.html">MPI_Gatherv</A></TD>
|
||||
<TD><A HREF="www3/MPI_T_cvar_handle_alloc.html">MPI_T_cvar_handle_alloc</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Bsend.html">MPI_Bsend</A></TD>
|
||||
<TD><A HREF="www3/MPI_Get_count.html">MPI_Get_count</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Alltoallw.html">MPI_Alltoallw</A></TD>
|
||||
<TD><A HREF="www3/MPI_Get.html">MPI_Get</A></TD>
|
||||
<TD><A HREF="www3/MPI_T_cvar_handle_free.html">MPI_T_cvar_handle_free</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Bsend_init.html">MPI_Bsend_init</A></TD>
|
||||
<TD><A HREF="www3/MPI_Get_elements.html">MPI_Get_elements</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Attr_delete.html">MPI_Attr_delete</A></TD>
|
||||
<TD><A HREF="www3/MPI_Get_accumulate.html">MPI_Get_accumulate</A></TD>
|
||||
<TD><A HREF="www3/MPI_T_cvar_read.html">MPI_T_cvar_read</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Buffer_attach.html">MPI_Buffer_attach</A></TD>
|
||||
<TD><A HREF="www3/MPI_Get_elements_x.html">MPI_Get_elements_x</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Attr_get.html">MPI_Attr_get</A></TD>
|
||||
<TD><A HREF="www3/MPI_Get_address.html">MPI_Get_address</A></TD>
|
||||
<TD><A HREF="www3/MPI_T_cvar_write.html">MPI_T_cvar_write</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Buffer_detach.html">MPI_Buffer_detach</A></TD>
|
||||
<TD><A HREF="www3/MPI_Get_library_version.html">MPI_Get_library_version</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Attr_put.html">MPI_Attr_put</A></TD>
|
||||
<TD><A HREF="www3/MPI_Get_count.html">MPI_Get_count</A></TD>
|
||||
<TD><A HREF="www3/MPI_T_enum_get_info.html">MPI_T_enum_get_info</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Cancel.html">MPI_Cancel</A></TD>
|
||||
<TD><A HREF="www3/MPI_Get_processor_name.html">MPI_Get_processor_name</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Barrier.html">MPI_Barrier</A></TD>
|
||||
<TD><A HREF="www3/MPI_Get_elements.html">MPI_Get_elements</A></TD>
|
||||
<TD><A HREF="www3/MPI_T_enum_get_item.html">MPI_T_enum_get_item</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Cart_coords.html">MPI_Cart_coords</A></TD>
|
||||
<TD><A HREF="www3/MPI_Get_version.html">MPI_Get_version</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Bcast.html">MPI_Bcast</A></TD>
|
||||
<TD><A HREF="www3/MPI_Get_elements_x.html">MPI_Get_elements_x</A></TD>
|
||||
<TD><A HREF="www3/MPI_T_finalize.html">MPI_T_finalize</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Cart_create.html">MPI_Cart_create</A></TD>
|
||||
<TD><A HREF="www3/MPI_Graph_create.html">MPI_Graph_create</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Bsend.html">MPI_Bsend</A></TD>
|
||||
<TD><A HREF="www3/MPI_Get_library_version.html">MPI_Get_library_version</A></TD>
|
||||
<TD><A HREF="www3/MPI_T_init_thread.html">MPI_T_init_thread</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Cart_get.html">MPI_Cart_get</A></TD>
|
||||
<TD><A HREF="www3/MPI_Graph_get.html">MPI_Graph_get</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Bsend_init.html">MPI_Bsend_init</A></TD>
|
||||
<TD><A HREF="www3/MPI_Get_processor_name.html">MPI_Get_processor_name</A></TD>
|
||||
<TD><A HREF="www3/MPI_T_pvar_get_info.html">MPI_T_pvar_get_info</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Cart_map.html">MPI_Cart_map</A></TD>
|
||||
<TD><A HREF="www3/MPI_Graph_map.html">MPI_Graph_map</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Buffer_attach.html">MPI_Buffer_attach</A></TD>
|
||||
<TD><A HREF="www3/MPI_Get_version.html">MPI_Get_version</A></TD>
|
||||
<TD><A HREF="www3/MPI_T_pvar_get_num.html">MPI_T_pvar_get_num</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Cart_rank.html">MPI_Cart_rank</A></TD>
|
||||
<TD><A HREF="www3/MPI_Graph_neighbors.html">MPI_Graph_neighbors</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Buffer_detach.html">MPI_Buffer_detach</A></TD>
|
||||
<TD><A HREF="www3/MPI_Graph_create.html">MPI_Graph_create</A></TD>
|
||||
<TD><A HREF="www3/MPI_T_pvar_handle_alloc.html">MPI_T_pvar_handle_alloc</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Cart_shift.html">MPI_Cart_shift</A></TD>
|
||||
<TD><A HREF="www3/MPI_Graph_neighbors_count.html">MPI_Graph_neighbors_count</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Cancel.html">MPI_Cancel</A></TD>
|
||||
<TD><A HREF="www3/MPI_Graph_get.html">MPI_Graph_get</A></TD>
|
||||
<TD><A HREF="www3/MPI_T_pvar_handle_free.html">MPI_T_pvar_handle_free</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Cart_sub.html">MPI_Cart_sub</A></TD>
|
||||
<TD><A HREF="www3/MPI_Graphdims_get.html">MPI_Graphdims_get</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Cart_coords.html">MPI_Cart_coords</A></TD>
|
||||
<TD><A HREF="www3/MPI_Graph_map.html">MPI_Graph_map</A></TD>
|
||||
<TD><A HREF="www3/MPI_T_pvar_read.html">MPI_T_pvar_read</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Cartdim_get.html">MPI_Cartdim_get</A></TD>
|
||||
<TD><A HREF="www3/MPI_Grequest_complete.html">MPI_Grequest_complete</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Cart_create.html">MPI_Cart_create</A></TD>
|
||||
<TD><A HREF="www3/MPI_Graph_neighbors.html">MPI_Graph_neighbors</A></TD>
|
||||
<TD><A HREF="www3/MPI_T_pvar_readreset.html">MPI_T_pvar_readreset</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Close_port.html">MPI_Close_port</A></TD>
|
||||
<TD><A HREF="www3/MPI_Grequest_start.html">MPI_Grequest_start</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Cart_get.html">MPI_Cart_get</A></TD>
|
||||
<TD><A HREF="www3/MPI_Graph_neighbors_count.html">MPI_Graph_neighbors_count</A></TD>
|
||||
<TD><A HREF="www3/MPI_T_pvar_reset.html">MPI_T_pvar_reset</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Comm_accept.html">MPI_Comm_accept</A></TD>
|
||||
<TD><A HREF="www3/MPI_Group_compare.html">MPI_Group_compare</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Cart_map.html">MPI_Cart_map</A></TD>
|
||||
<TD><A HREF="www3/MPI_Graphdims_get.html">MPI_Graphdims_get</A></TD>
|
||||
<TD><A HREF="www3/MPI_T_pvar_session_create.html">MPI_T_pvar_session_create</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Comm_call_errhandler.html">MPI_Comm_call_errhandler</A></TD>
|
||||
<TD><A HREF="www3/MPI_Group_difference.html">MPI_Group_difference</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Cart_rank.html">MPI_Cart_rank</A></TD>
|
||||
<TD><A HREF="www3/MPI_Grequest_complete.html">MPI_Grequest_complete</A></TD>
|
||||
<TD><A HREF="www3/MPI_T_pvar_session_free.html">MPI_T_pvar_session_free</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Comm_compare.html">MPI_Comm_compare</A></TD>
|
||||
<TD><A HREF="www3/MPI_Group_excl.html">MPI_Group_excl</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Cart_shift.html">MPI_Cart_shift</A></TD>
|
||||
<TD><A HREF="www3/MPI_Grequest_start.html">MPI_Grequest_start</A></TD>
|
||||
<TD><A HREF="www3/MPI_T_pvar_start.html">MPI_T_pvar_start</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Comm_connect.html">MPI_Comm_connect</A></TD>
|
||||
<TD><A HREF="www3/MPI_Group_free.html">MPI_Group_free</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Cart_sub.html">MPI_Cart_sub</A></TD>
|
||||
<TD><A HREF="www3/MPI_Group_compare.html">MPI_Group_compare</A></TD>
|
||||
<TD><A HREF="www3/MPI_T_pvar_stop.html">MPI_T_pvar_stop</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Comm_create.html">MPI_Comm_create</A></TD>
|
||||
<TD><A HREF="www3/MPI_Group_incl.html">MPI_Group_incl</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Cartdim_get.html">MPI_Cartdim_get</A></TD>
|
||||
<TD><A HREF="www3/MPI_Group_difference.html">MPI_Group_difference</A></TD>
|
||||
<TD><A HREF="www3/MPI_T_pvar_write.html">MPI_T_pvar_write</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Comm_create_errhandler.html">MPI_Comm_create_errhandler</A></TD>
|
||||
<TD><A HREF="www3/MPI_Group_intersection.html">MPI_Group_intersection</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Close_port.html">MPI_Close_port</A></TD>
|
||||
<TD><A HREF="www3/MPI_Group_excl.html">MPI_Group_excl</A></TD>
|
||||
<TD><A HREF="www3/MPI_Test.html">MPI_Test</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Comm_create_group.html">MPI_Comm_create_group</A></TD>
|
||||
<TD><A HREF="www3/MPI_Group_range_excl.html">MPI_Group_range_excl</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Comm_accept.html">MPI_Comm_accept</A></TD>
|
||||
<TD><A HREF="www3/MPI_Group_free.html">MPI_Group_free</A></TD>
|
||||
<TD><A HREF="www3/MPI_Test_cancelled.html">MPI_Test_cancelled</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Comm_create_keyval.html">MPI_Comm_create_keyval</A></TD>
|
||||
<TD><A HREF="www3/MPI_Group_range_incl.html">MPI_Group_range_incl</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Comm_call_errhandler.html">MPI_Comm_call_errhandler</A></TD>
|
||||
<TD><A HREF="www3/MPI_Group_incl.html">MPI_Group_incl</A></TD>
|
||||
<TD><A HREF="www3/MPI_Testall.html">MPI_Testall</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Comm_delete_attr.html">MPI_Comm_delete_attr</A></TD>
|
||||
<TD><A HREF="www3/MPI_Group_rank.html">MPI_Group_rank</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Comm_compare.html">MPI_Comm_compare</A></TD>
|
||||
<TD><A HREF="www3/MPI_Group_intersection.html">MPI_Group_intersection</A></TD>
|
||||
<TD><A HREF="www3/MPI_Testany.html">MPI_Testany</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Comm_disconnect.html">MPI_Comm_disconnect</A></TD>
|
||||
<TD><A HREF="www3/MPI_Group_size.html">MPI_Group_size</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Comm_connect.html">MPI_Comm_connect</A></TD>
|
||||
<TD><A HREF="www3/MPI_Group_range_excl.html">MPI_Group_range_excl</A></TD>
|
||||
<TD><A HREF="www3/MPI_Testsome.html">MPI_Testsome</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Comm_dup.html">MPI_Comm_dup</A></TD>
|
||||
<TD><A HREF="www3/MPI_Group_translate_ranks.html">MPI_Group_translate_ranks</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Comm_create.html">MPI_Comm_create</A></TD>
|
||||
<TD><A HREF="www3/MPI_Group_range_incl.html">MPI_Group_range_incl</A></TD>
|
||||
<TD><A HREF="www3/MPI_Topo_test.html">MPI_Topo_test</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Comm_dup_with_info.html">MPI_Comm_dup_with_info</A></TD>
|
||||
<TD><A HREF="www3/MPI_Group_union.html">MPI_Group_union</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Comm_create_errhandler.html">MPI_Comm_create_errhandler</A></TD>
|
||||
<TD><A HREF="www3/MPI_Group_rank.html">MPI_Group_rank</A></TD>
|
||||
<TD><A HREF="www3/MPI_Type_commit.html">MPI_Type_commit</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Comm_free.html">MPI_Comm_free</A></TD>
|
||||
<TD><A HREF="www3/MPI_Iallgather.html">MPI_Iallgather</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Comm_create_group.html">MPI_Comm_create_group</A></TD>
|
||||
<TD><A HREF="www3/MPI_Group_size.html">MPI_Group_size</A></TD>
|
||||
<TD><A HREF="www3/MPI_Type_contiguous.html">MPI_Type_contiguous</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Comm_free_keyval.html">MPI_Comm_free_keyval</A></TD>
|
||||
<TD><A HREF="www3/MPI_Iallgatherv.html">MPI_Iallgatherv</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Comm_create_keyval.html">MPI_Comm_create_keyval</A></TD>
|
||||
<TD><A HREF="www3/MPI_Group_translate_ranks.html">MPI_Group_translate_ranks</A></TD>
|
||||
<TD><A HREF="www3/MPI_Type_create_darray.html">MPI_Type_create_darray</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Comm_get_attr.html">MPI_Comm_get_attr</A></TD>
|
||||
<TD><A HREF="www3/MPI_Iallreduce.html">MPI_Iallreduce</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Comm_delete_attr.html">MPI_Comm_delete_attr</A></TD>
|
||||
<TD><A HREF="www3/MPI_Group_union.html">MPI_Group_union</A></TD>
|
||||
<TD><A HREF="www3/MPI_Type_create_hindexed.html">MPI_Type_create_hindexed</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Comm_get_errhandler.html">MPI_Comm_get_errhandler</A></TD>
|
||||
<TD><A HREF="www3/MPI_Ialltoall.html">MPI_Ialltoall</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Comm_disconnect.html">MPI_Comm_disconnect</A></TD>
|
||||
<TD><A HREF="www3/MPI_Iallgather.html">MPI_Iallgather</A></TD>
|
||||
<TD><A HREF="www3/MPI_Type_create_hindexed_block.html">MPI_Type_create_hindexed_block</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Comm_get_info.html">MPI_Comm_get_info</A></TD>
|
||||
<TD><A HREF="www3/MPI_Ialltoallv.html">MPI_Ialltoallv</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Comm_dup.html">MPI_Comm_dup</A></TD>
|
||||
<TD><A HREF="www3/MPI_Iallgatherv.html">MPI_Iallgatherv</A></TD>
|
||||
<TD><A HREF="www3/MPI_Type_create_hvector.html">MPI_Type_create_hvector</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Comm_get_name.html">MPI_Comm_get_name</A></TD>
|
||||
<TD><A HREF="www3/MPI_Ialltoallw.html">MPI_Ialltoallw</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Comm_dup_with_info.html">MPI_Comm_dup_with_info</A></TD>
|
||||
<TD><A HREF="www3/MPI_Iallreduce.html">MPI_Iallreduce</A></TD>
|
||||
<TD><A HREF="www3/MPI_Type_create_indexed_block.html">MPI_Type_create_indexed_block</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Comm_get_parent.html">MPI_Comm_get_parent</A></TD>
|
||||
<TD><A HREF="www3/MPI_Ibarrier.html">MPI_Ibarrier</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Comm_free.html">MPI_Comm_free</A></TD>
|
||||
<TD><A HREF="www3/MPI_Ialltoall.html">MPI_Ialltoall</A></TD>
|
||||
<TD><A HREF="www3/MPI_Type_create_keyval.html">MPI_Type_create_keyval</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Comm_group.html">MPI_Comm_group</A></TD>
|
||||
<TD><A HREF="www3/MPI_Ibcast.html">MPI_Ibcast</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Comm_free_keyval.html">MPI_Comm_free_keyval</A></TD>
|
||||
<TD><A HREF="www3/MPI_Ialltoallv.html">MPI_Ialltoallv</A></TD>
|
||||
<TD><A HREF="www3/MPI_Type_create_resized.html">MPI_Type_create_resized</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Comm_idup.html">MPI_Comm_idup</A></TD>
|
||||
<TD><A HREF="www3/MPI_Ibsend.html">MPI_Ibsend</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Comm_get_attr.html">MPI_Comm_get_attr</A></TD>
|
||||
<TD><A HREF="www3/MPI_Ialltoallw.html">MPI_Ialltoallw</A></TD>
|
||||
<TD><A HREF="www3/MPI_Type_create_struct.html">MPI_Type_create_struct</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Comm_join.html">MPI_Comm_join</A></TD>
|
||||
<TD><A HREF="www3/MPI_Iexscan.html">MPI_Iexscan</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Comm_get_errhandler.html">MPI_Comm_get_errhandler</A></TD>
|
||||
<TD><A HREF="www3/MPI_Ibarrier.html">MPI_Ibarrier</A></TD>
|
||||
<TD><A HREF="www3/MPI_Type_create_subarray.html">MPI_Type_create_subarray</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Comm_rank.html">MPI_Comm_rank</A></TD>
|
||||
<TD><A HREF="www3/MPI_Igather.html">MPI_Igather</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Comm_get_info.html">MPI_Comm_get_info</A></TD>
|
||||
<TD><A HREF="www3/MPI_Ibcast.html">MPI_Ibcast</A></TD>
|
||||
<TD><A HREF="www3/MPI_Type_delete_attr.html">MPI_Type_delete_attr</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Comm_remote_group.html">MPI_Comm_remote_group</A></TD>
|
||||
<TD><A HREF="www3/MPI_Igatherv.html">MPI_Igatherv</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Comm_get_name.html">MPI_Comm_get_name</A></TD>
|
||||
<TD><A HREF="www3/MPI_Ibsend.html">MPI_Ibsend</A></TD>
|
||||
<TD><A HREF="www3/MPI_Type_dup.html">MPI_Type_dup</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Comm_remote_size.html">MPI_Comm_remote_size</A></TD>
|
||||
<TD><A HREF="www3/MPI_Improbe.html">MPI_Improbe</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Comm_get_parent.html">MPI_Comm_get_parent</A></TD>
|
||||
<TD><A HREF="www3/MPI_Iexscan.html">MPI_Iexscan</A></TD>
|
||||
<TD><A HREF="www3/MPI_Type_extent.html">MPI_Type_extent</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Comm_set_attr.html">MPI_Comm_set_attr</A></TD>
|
||||
<TD><A HREF="www3/MPI_Imrecv.html">MPI_Imrecv</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Comm_group.html">MPI_Comm_group</A></TD>
|
||||
<TD><A HREF="www3/MPI_Igather.html">MPI_Igather</A></TD>
|
||||
<TD><A HREF="www3/MPI_Type_free.html">MPI_Type_free</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Comm_set_errhandler.html">MPI_Comm_set_errhandler</A></TD>
|
||||
<TD><A HREF="www3/MPI_Ineighbor_allgather.html">MPI_Ineighbor_allgather</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Comm_idup.html">MPI_Comm_idup</A></TD>
|
||||
<TD><A HREF="www3/MPI_Igatherv.html">MPI_Igatherv</A></TD>
|
||||
<TD><A HREF="www3/MPI_Type_free_keyval.html">MPI_Type_free_keyval</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Comm_set_info.html">MPI_Comm_set_info</A></TD>
|
||||
<TD><A HREF="www3/MPI_Ineighbor_allgatherv.html">MPI_Ineighbor_allgatherv</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Comm_join.html">MPI_Comm_join</A></TD>
|
||||
<TD><A HREF="www3/MPI_Improbe.html">MPI_Improbe</A></TD>
|
||||
<TD><A HREF="www3/MPI_Type_get_attr.html">MPI_Type_get_attr</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Comm_set_name.html">MPI_Comm_set_name</A></TD>
|
||||
<TD><A HREF="www3/MPI_Ineighbor_alltoall.html">MPI_Ineighbor_alltoall</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Comm_rank.html">MPI_Comm_rank</A></TD>
|
||||
<TD><A HREF="www3/MPI_Imrecv.html">MPI_Imrecv</A></TD>
|
||||
<TD><A HREF="www3/MPI_Type_get_contents.html">MPI_Type_get_contents</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Comm_size.html">MPI_Comm_size</A></TD>
|
||||
<TD><A HREF="www3/MPI_Ineighbor_alltoallv.html">MPI_Ineighbor_alltoallv</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Comm_remote_group.html">MPI_Comm_remote_group</A></TD>
|
||||
<TD><A HREF="www3/MPI_Ineighbor_allgather.html">MPI_Ineighbor_allgather</A></TD>
|
||||
<TD><A HREF="www3/MPI_Type_get_envelope.html">MPI_Type_get_envelope</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Comm_spawn.html">MPI_Comm_spawn</A></TD>
|
||||
<TD><A HREF="www3/MPI_Ineighbor_alltoallw.html">MPI_Ineighbor_alltoallw</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Comm_remote_size.html">MPI_Comm_remote_size</A></TD>
|
||||
<TD><A HREF="www3/MPI_Ineighbor_allgatherv.html">MPI_Ineighbor_allgatherv</A></TD>
|
||||
<TD><A HREF="www3/MPI_Type_get_extent.html">MPI_Type_get_extent</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Comm_spawn_multiple.html">MPI_Comm_spawn_multiple</A></TD>
|
||||
<TD><A HREF="www3/MPI_Info_create.html">MPI_Info_create</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Comm_set_attr.html">MPI_Comm_set_attr</A></TD>
|
||||
<TD><A HREF="www3/MPI_Ineighbor_alltoall.html">MPI_Ineighbor_alltoall</A></TD>
|
||||
<TD><A HREF="www3/MPI_Type_get_extent_x.html">MPI_Type_get_extent_x</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Comm_split.html">MPI_Comm_split</A></TD>
|
||||
<TD><A HREF="www3/MPI_Info_delete.html">MPI_Info_delete</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Comm_set_errhandler.html">MPI_Comm_set_errhandler</A></TD>
|
||||
<TD><A HREF="www3/MPI_Ineighbor_alltoallv.html">MPI_Ineighbor_alltoallv</A></TD>
|
||||
<TD><A HREF="www3/MPI_Type_get_name.html">MPI_Type_get_name</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Comm_split_type.html">MPI_Comm_split_type</A></TD>
|
||||
<TD><A HREF="www3/MPI_Info_dup.html">MPI_Info_dup</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Comm_set_info.html">MPI_Comm_set_info</A></TD>
|
||||
<TD><A HREF="www3/MPI_Ineighbor_alltoallw.html">MPI_Ineighbor_alltoallw</A></TD>
|
||||
<TD><A HREF="www3/MPI_Type_get_true_extent.html">MPI_Type_get_true_extent</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Comm_test_inter.html">MPI_Comm_test_inter</A></TD>
|
||||
<TD><A HREF="www3/MPI_Info_free.html">MPI_Info_free</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Comm_set_name.html">MPI_Comm_set_name</A></TD>
|
||||
<TD><A HREF="www3/MPI_Info_create.html">MPI_Info_create</A></TD>
|
||||
<TD><A HREF="www3/MPI_Type_get_true_extent_x.html">MPI_Type_get_true_extent_x</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Compare_and_swap.html">MPI_Compare_and_swap</A></TD>
|
||||
<TD><A HREF="www3/MPI_Info_get.html">MPI_Info_get</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Comm_size.html">MPI_Comm_size</A></TD>
|
||||
<TD><A HREF="www3/MPI_Info_delete.html">MPI_Info_delete</A></TD>
|
||||
<TD><A HREF="www3/MPI_Type_hindexed.html">MPI_Type_hindexed</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Dims_create.html">MPI_Dims_create</A></TD>
|
||||
<TD><A HREF="www3/MPI_Info_get_nkeys.html">MPI_Info_get_nkeys</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Comm_spawn.html">MPI_Comm_spawn</A></TD>
|
||||
<TD><A HREF="www3/MPI_Info_dup.html">MPI_Info_dup</A></TD>
|
||||
<TD><A HREF="www3/MPI_Type_hvector.html">MPI_Type_hvector</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Dist_graph_create.html">MPI_Dist_graph_create</A></TD>
|
||||
<TD><A HREF="www3/MPI_Info_get_nthkey.html">MPI_Info_get_nthkey</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Comm_spawn_multiple.html">MPI_Comm_spawn_multiple</A></TD>
|
||||
<TD><A HREF="www3/MPI_Info_free.html">MPI_Info_free</A></TD>
|
||||
<TD><A HREF="www3/MPI_Type_indexed.html">MPI_Type_indexed</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Dist_graph_create_adjacent.html">MPI_Dist_graph_create_adjacent</A></TD>
|
||||
<TD><A HREF="www3/MPI_Info_get_valuelen.html">MPI_Info_get_valuelen</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Comm_split.html">MPI_Comm_split</A></TD>
|
||||
<TD><A HREF="www3/MPI_Info_get.html">MPI_Info_get</A></TD>
|
||||
<TD><A HREF="www3/MPI_Type_lb.html">MPI_Type_lb</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Dist_graph_neighbors.html">MPI_Dist_graph_neighbors</A></TD>
|
||||
<TD><A HREF="www3/MPI_Info_set.html">MPI_Info_set</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Comm_split_type.html">MPI_Comm_split_type</A></TD>
|
||||
<TD><A HREF="www3/MPI_Info_get_nkeys.html">MPI_Info_get_nkeys</A></TD>
|
||||
<TD><A HREF="www3/MPI_Type_match_size.html">MPI_Type_match_size</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Dist_graph_neighbors_count.html">MPI_Dist_graph_neighbors_count</A></TD>
|
||||
<TD><A HREF="www3/MPI_Init.html">MPI_Init</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Comm_test_inter.html">MPI_Comm_test_inter</A></TD>
|
||||
<TD><A HREF="www3/MPI_Info_get_nthkey.html">MPI_Info_get_nthkey</A></TD>
|
||||
<TD><A HREF="www3/MPI_Type_set_attr.html">MPI_Type_set_attr</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Errhandler_create.html">MPI_Errhandler_create</A></TD>
|
||||
<TD><A HREF="www3/MPI_Init_thread.html">MPI_Init_thread</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Compare_and_swap.html">MPI_Compare_and_swap</A></TD>
|
||||
<TD><A HREF="www3/MPI_Info_get_valuelen.html">MPI_Info_get_valuelen</A></TD>
|
||||
<TD><A HREF="www3/MPI_Type_set_name.html">MPI_Type_set_name</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Errhandler_free.html">MPI_Errhandler_free</A></TD>
|
||||
<TD><A HREF="www3/MPI_Initialized.html">MPI_Initialized</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Dims_create.html">MPI_Dims_create</A></TD>
|
||||
<TD><A HREF="www3/MPI_Info_set.html">MPI_Info_set</A></TD>
|
||||
<TD><A HREF="www3/MPI_Type_size.html">MPI_Type_size</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Errhandler_get.html">MPI_Errhandler_get</A></TD>
|
||||
<TD><A HREF="www3/MPI_Intercomm_create.html">MPI_Intercomm_create</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Dist_graph_create.html">MPI_Dist_graph_create</A></TD>
|
||||
<TD><A HREF="www3/MPI_Init.html">MPI_Init</A></TD>
|
||||
<TD><A HREF="www3/MPI_Type_size_x.html">MPI_Type_size_x</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Errhandler_set.html">MPI_Errhandler_set</A></TD>
|
||||
<TD><A HREF="www3/MPI_Intercomm_merge.html">MPI_Intercomm_merge</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Dist_graph_create_adjacent.html">MPI_Dist_graph_create_adjacent</A></TD>
|
||||
<TD><A HREF="www3/MPI_Init_thread.html">MPI_Init_thread</A></TD>
|
||||
<TD><A HREF="www3/MPI_Type_struct.html">MPI_Type_struct</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Error_class.html">MPI_Error_class</A></TD>
|
||||
<TD><A HREF="www3/MPI_Iprobe.html">MPI_Iprobe</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Dist_graph_neighbors.html">MPI_Dist_graph_neighbors</A></TD>
|
||||
<TD><A HREF="www3/MPI_Initialized.html">MPI_Initialized</A></TD>
|
||||
<TD><A HREF="www3/MPI_Type_ub.html">MPI_Type_ub</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Error_string.html">MPI_Error_string</A></TD>
|
||||
<TD><A HREF="www3/MPI_Irecv.html">MPI_Irecv</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Dist_graph_neighbors_count.html">MPI_Dist_graph_neighbors_count</A></TD>
|
||||
<TD><A HREF="www3/MPI_Intercomm_create.html">MPI_Intercomm_create</A></TD>
|
||||
<TD><A HREF="www3/MPI_Type_vector.html">MPI_Type_vector</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Exscan.html">MPI_Exscan</A></TD>
|
||||
<TD><A HREF="www3/MPI_Ireduce.html">MPI_Ireduce</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Errhandler_create.html">MPI_Errhandler_create</A></TD>
|
||||
<TD><A HREF="www3/MPI_Intercomm_merge.html">MPI_Intercomm_merge</A></TD>
|
||||
<TD><A HREF="www3/MPI_Unpack.html">MPI_Unpack</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_Fetch_and_op.html">MPI_Fetch_and_op</A></TD>
|
||||
<TD><A HREF="www3/MPI_Ireduce_scatter.html">MPI_Ireduce_scatter</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Errhandler_free.html">MPI_Errhandler_free</A></TD>
|
||||
<TD><A HREF="www3/MPI_Iprobe.html">MPI_Iprobe</A></TD>
|
||||
<TD><A HREF="www3/MPI_Unpack_external.html">MPI_Unpack_external</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_File_c2f.html">MPI_File_c2f</A></TD>
|
||||
<TD><A HREF="www3/MPI_Ireduce_scatter_block.html">MPI_Ireduce_scatter_block</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Errhandler_get.html">MPI_Errhandler_get</A></TD>
|
||||
<TD><A HREF="www3/MPI_Irecv.html">MPI_Irecv</A></TD>
|
||||
<TD><A HREF="www3/MPI_Unpublish_name.html">MPI_Unpublish_name</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_File_call_errhandler.html">MPI_File_call_errhandler</A></TD>
|
||||
<TD><A HREF="www3/MPI_Irsend.html">MPI_Irsend</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Errhandler_set.html">MPI_Errhandler_set</A></TD>
|
||||
<TD><A HREF="www3/MPI_Ireduce.html">MPI_Ireduce</A></TD>
|
||||
<TD><A HREF="www3/MPI_Wait.html">MPI_Wait</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_File_close.html">MPI_File_close</A></TD>
|
||||
<TD><A HREF="www3/MPI_Is_thread_main.html">MPI_Is_thread_main</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Error_class.html">MPI_Error_class</A></TD>
|
||||
<TD><A HREF="www3/MPI_Ireduce_scatter.html">MPI_Ireduce_scatter</A></TD>
|
||||
<TD><A HREF="www3/MPI_Waitall.html">MPI_Waitall</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_File_create_errhandler.html">MPI_File_create_errhandler</A></TD>
|
||||
<TD><A HREF="www3/MPI_Iscan.html">MPI_Iscan</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Error_string.html">MPI_Error_string</A></TD>
|
||||
<TD><A HREF="www3/MPI_Ireduce_scatter_block.html">MPI_Ireduce_scatter_block</A></TD>
|
||||
<TD><A HREF="www3/MPI_Waitany.html">MPI_Waitany</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_File_delete.html">MPI_File_delete</A></TD>
|
||||
<TD><A HREF="www3/MPI_Iscatter.html">MPI_Iscatter</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Exscan.html">MPI_Exscan</A></TD>
|
||||
<TD><A HREF="www3/MPI_Irsend.html">MPI_Irsend</A></TD>
|
||||
<TD><A HREF="www3/MPI_Waitsome.html">MPI_Waitsome</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_File_f2c.html">MPI_File_f2c</A></TD>
|
||||
<TD><A HREF="www3/MPI_Iscatterv.html">MPI_Iscatterv</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_Fetch_and_op.html">MPI_Fetch_and_op</A></TD>
|
||||
<TD><A HREF="www3/MPI_Is_thread_main.html">MPI_Is_thread_main</A></TD>
|
||||
<TD><A HREF="www3/MPI_Win_allocate.html">MPI_Win_allocate</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_File_get_amode.html">MPI_File_get_amode</A></TD>
|
||||
<TD><A HREF="www3/MPI_Isend.html">MPI_Isend</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_File_c2f.html">MPI_File_c2f</A></TD>
|
||||
<TD><A HREF="www3/MPI_Iscan.html">MPI_Iscan</A></TD>
|
||||
<TD><A HREF="www3/MPI_Win_allocate_shared.html">MPI_Win_allocate_shared</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_File_get_atomicity.html">MPI_File_get_atomicity</A></TD>
|
||||
<TD><A HREF="www3/MPI_Issend.html">MPI_Issend</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_File_call_errhandler.html">MPI_File_call_errhandler</A></TD>
|
||||
<TD><A HREF="www3/MPI_Iscatter.html">MPI_Iscatter</A></TD>
|
||||
<TD><A HREF="www3/MPI_Win_attach.html">MPI_Win_attach</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_File_get_byte_offset.html">MPI_File_get_byte_offset</A></TD>
|
||||
<TD><A HREF="www3/MPI_Keyval_create.html">MPI_Keyval_create</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_File_close.html">MPI_File_close</A></TD>
|
||||
<TD><A HREF="www3/MPI_Iscatterv.html">MPI_Iscatterv</A></TD>
|
||||
<TD><A HREF="www3/MPI_Win_call_errhandler.html">MPI_Win_call_errhandler</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_File_get_errhandler.html">MPI_File_get_errhandler</A></TD>
|
||||
<TD><A HREF="www3/MPI_Keyval_free.html">MPI_Keyval_free</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_File_create_errhandler.html">MPI_File_create_errhandler</A></TD>
|
||||
<TD><A HREF="www3/MPI_Isend.html">MPI_Isend</A></TD>
|
||||
<TD><A HREF="www3/MPI_Win_complete.html">MPI_Win_complete</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_File_get_group.html">MPI_File_get_group</A></TD>
|
||||
<TD><A HREF="www3/MPI_Lookup_name.html">MPI_Lookup_name</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_File_delete.html">MPI_File_delete</A></TD>
|
||||
<TD><A HREF="www3/MPI_Issend.html">MPI_Issend</A></TD>
|
||||
<TD><A HREF="www3/MPI_Win_create.html">MPI_Win_create</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_File_get_info.html">MPI_File_get_info</A></TD>
|
||||
<TD><A HREF="www3/MPI_Mprobe.html">MPI_Mprobe</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_File_f2c.html">MPI_File_f2c</A></TD>
|
||||
<TD><A HREF="www3/MPI_Keyval_create.html">MPI_Keyval_create</A></TD>
|
||||
<TD><A HREF="www3/MPI_Win_create_dynamic.html">MPI_Win_create_dynamic</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_File_get_position.html">MPI_File_get_position</A></TD>
|
||||
<TD><A HREF="www3/MPI_Mrecv.html">MPI_Mrecv</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_File_get_amode.html">MPI_File_get_amode</A></TD>
|
||||
<TD><A HREF="www3/MPI_Keyval_free.html">MPI_Keyval_free</A></TD>
|
||||
<TD><A HREF="www3/MPI_Win_create_errhandler.html">MPI_Win_create_errhandler</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_File_get_position_shared.html">MPI_File_get_position_shared</A></TD>
|
||||
<TD><A HREF="www3/MPI_Neighbor_allgather.html">MPI_Neighbor_allgather</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_File_get_atomicity.html">MPI_File_get_atomicity</A></TD>
|
||||
<TD><A HREF="www3/MPI_Lookup_name.html">MPI_Lookup_name</A></TD>
|
||||
<TD><A HREF="www3/MPI_Win_create_keyval.html">MPI_Win_create_keyval</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_File_get_size.html">MPI_File_get_size</A></TD>
|
||||
<TD><A HREF="www3/MPI_Neighbor_allgatherv.html">MPI_Neighbor_allgatherv</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_File_get_byte_offset.html">MPI_File_get_byte_offset</A></TD>
|
||||
<TD><A HREF="www3/MPI_Mprobe.html">MPI_Mprobe</A></TD>
|
||||
<TD><A HREF="www3/MPI_Win_delete_attr.html">MPI_Win_delete_attr</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_File_get_type_extent.html">MPI_File_get_type_extent</A></TD>
|
||||
<TD><A HREF="www3/MPI_Neighbor_alltoall.html">MPI_Neighbor_alltoall</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_File_get_errhandler.html">MPI_File_get_errhandler</A></TD>
|
||||
<TD><A HREF="www3/MPI_Mrecv.html">MPI_Mrecv</A></TD>
|
||||
<TD><A HREF="www3/MPI_Win_detach.html">MPI_Win_detach</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_File_get_view.html">MPI_File_get_view</A></TD>
|
||||
<TD><A HREF="www3/MPI_Neighbor_alltoallv.html">MPI_Neighbor_alltoallv</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_File_get_group.html">MPI_File_get_group</A></TD>
|
||||
<TD><A HREF="www3/MPI_Neighbor_allgather.html">MPI_Neighbor_allgather</A></TD>
|
||||
<TD><A HREF="www3/MPI_Win_fence.html">MPI_Win_fence</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_File_iread.html">MPI_File_iread</A></TD>
|
||||
<TD><A HREF="www3/MPI_Neighbor_alltoallw.html">MPI_Neighbor_alltoallw</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_File_get_info.html">MPI_File_get_info</A></TD>
|
||||
<TD><A HREF="www3/MPI_Neighbor_allgatherv.html">MPI_Neighbor_allgatherv</A></TD>
|
||||
<TD><A HREF="www3/MPI_Win_flush.html">MPI_Win_flush</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_File_iread_all.html">MPI_File_iread_all</A></TD>
|
||||
<TD><A HREF="www3/MPI_Op_commute.html">MPI_Op_commute</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_File_get_position.html">MPI_File_get_position</A></TD>
|
||||
<TD><A HREF="www3/MPI_Neighbor_alltoall.html">MPI_Neighbor_alltoall</A></TD>
|
||||
<TD><A HREF="www3/MPI_Win_flush_all.html">MPI_Win_flush_all</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_File_iread_at.html">MPI_File_iread_at</A></TD>
|
||||
<TD><A HREF="www3/MPI_Op_create.html">MPI_Op_create</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_File_get_position_shared.html">MPI_File_get_position_shared</A></TD>
|
||||
<TD><A HREF="www3/MPI_Neighbor_alltoallv.html">MPI_Neighbor_alltoallv</A></TD>
|
||||
<TD><A HREF="www3/MPI_Win_flush_local.html">MPI_Win_flush_local</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_File_iread_at_all.html">MPI_File_iread_at_all</A></TD>
|
||||
<TD><A HREF="www3/MPI_Op_free.html">MPI_Op_free</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_File_get_size.html">MPI_File_get_size</A></TD>
|
||||
<TD><A HREF="www3/MPI_Neighbor_alltoallw.html">MPI_Neighbor_alltoallw</A></TD>
|
||||
<TD><A HREF="www3/MPI_Win_flush_local_all.html">MPI_Win_flush_local_all</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_File_iread_shared.html">MPI_File_iread_shared</A></TD>
|
||||
<TD><A HREF="www3/MPI_Open_port.html">MPI_Open_port</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_File_get_type_extent.html">MPI_File_get_type_extent</A></TD>
|
||||
<TD><A HREF="www3/MPI_Op_commute.html">MPI_Op_commute</A></TD>
|
||||
<TD><A HREF="www3/MPI_Win_free.html">MPI_Win_free</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_File_iwrite.html">MPI_File_iwrite</A></TD>
|
||||
<TD><A HREF="www3/MPI_Pack.html">MPI_Pack</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_File_get_view.html">MPI_File_get_view</A></TD>
|
||||
<TD><A HREF="www3/MPI_Op_create.html">MPI_Op_create</A></TD>
|
||||
<TD><A HREF="www3/MPI_Win_free_keyval.html">MPI_Win_free_keyval</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_File_iwrite_all.html">MPI_File_iwrite_all</A></TD>
|
||||
<TD><A HREF="www3/MPI_Pack_external.html">MPI_Pack_external</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_File_iread.html">MPI_File_iread</A></TD>
|
||||
<TD><A HREF="www3/MPI_Op_free.html">MPI_Op_free</A></TD>
|
||||
<TD><A HREF="www3/MPI_Win_get_attr.html">MPI_Win_get_attr</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_File_iwrite_at.html">MPI_File_iwrite_at</A></TD>
|
||||
<TD><A HREF="www3/MPI_Pack_external_size.html">MPI_Pack_external_size</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_File_iread_all.html">MPI_File_iread_all</A></TD>
|
||||
<TD><A HREF="www3/MPI_Open_port.html">MPI_Open_port</A></TD>
|
||||
<TD><A HREF="www3/MPI_Win_get_errhandler.html">MPI_Win_get_errhandler</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_File_iwrite_at_all.html">MPI_File_iwrite_at_all</A></TD>
|
||||
<TD><A HREF="www3/MPI_Pack_size.html">MPI_Pack_size</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_File_iread_at.html">MPI_File_iread_at</A></TD>
|
||||
<TD><A HREF="www3/MPI_Pack.html">MPI_Pack</A></TD>
|
||||
<TD><A HREF="www3/MPI_Win_get_group.html">MPI_Win_get_group</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_File_iwrite_shared.html">MPI_File_iwrite_shared</A></TD>
|
||||
<TD><A HREF="www3/MPI_Pcontrol.html">MPI_Pcontrol</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_File_iread_at_all.html">MPI_File_iread_at_all</A></TD>
|
||||
<TD><A HREF="www3/MPI_Pack_external.html">MPI_Pack_external</A></TD>
|
||||
<TD><A HREF="www3/MPI_Win_get_info.html">MPI_Win_get_info</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_File_open.html">MPI_File_open</A></TD>
|
||||
<TD><A HREF="www3/MPI_Probe.html">MPI_Probe</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_File_iread_shared.html">MPI_File_iread_shared</A></TD>
|
||||
<TD><A HREF="www3/MPI_Pack_external_size.html">MPI_Pack_external_size</A></TD>
|
||||
<TD><A HREF="www3/MPI_Win_get_name.html">MPI_Win_get_name</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_File_preallocate.html">MPI_File_preallocate</A></TD>
|
||||
<TD><A HREF="www3/MPI_Publish_name.html">MPI_Publish_name</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_File_iwrite.html">MPI_File_iwrite</A></TD>
|
||||
<TD><A HREF="www3/MPI_Pack_size.html">MPI_Pack_size</A></TD>
|
||||
<TD><A HREF="www3/MPI_Win_lock.html">MPI_Win_lock</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_File_read.html">MPI_File_read</A></TD>
|
||||
<TD><A HREF="www3/MPI_Put.html">MPI_Put</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_File_iwrite_all.html">MPI_File_iwrite_all</A></TD>
|
||||
<TD><A HREF="www3/MPI_Pcontrol.html">MPI_Pcontrol</A></TD>
|
||||
<TD><A HREF="www3/MPI_Win_lock_all.html">MPI_Win_lock_all</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_File_read_all.html">MPI_File_read_all</A></TD>
|
||||
<TD><A HREF="www3/MPI_Query_thread.html">MPI_Query_thread</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_File_iwrite_at.html">MPI_File_iwrite_at</A></TD>
|
||||
<TD><A HREF="www3/MPI_Probe.html">MPI_Probe</A></TD>
|
||||
<TD><A HREF="www3/MPI_Win_post.html">MPI_Win_post</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_File_read_all_begin.html">MPI_File_read_all_begin</A></TD>
|
||||
<TD><A HREF="www3/MPI_Raccumulate.html">MPI_Raccumulate</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_File_iwrite_at_all.html">MPI_File_iwrite_at_all</A></TD>
|
||||
<TD><A HREF="www3/MPI_Publish_name.html">MPI_Publish_name</A></TD>
|
||||
<TD><A HREF="www3/MPI_Win_set_attr.html">MPI_Win_set_attr</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_File_read_all_end.html">MPI_File_read_all_end</A></TD>
|
||||
<TD><A HREF="www3/MPI_Recv.html">MPI_Recv</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_File_iwrite_shared.html">MPI_File_iwrite_shared</A></TD>
|
||||
<TD><A HREF="www3/MPI_Put.html">MPI_Put</A></TD>
|
||||
<TD><A HREF="www3/MPI_Win_set_errhandler.html">MPI_Win_set_errhandler</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_File_read_at.html">MPI_File_read_at</A></TD>
|
||||
<TD><A HREF="www3/MPI_Recv_init.html">MPI_Recv_init</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_File_open.html">MPI_File_open</A></TD>
|
||||
<TD><A HREF="www3/MPI_Query_thread.html">MPI_Query_thread</A></TD>
|
||||
<TD><A HREF="www3/MPI_Win_set_info.html">MPI_Win_set_info</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_File_read_at_all.html">MPI_File_read_at_all</A></TD>
|
||||
<TD><A HREF="www3/MPI_Reduce.html">MPI_Reduce</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_File_preallocate.html">MPI_File_preallocate</A></TD>
|
||||
<TD><A HREF="www3/MPI_Raccumulate.html">MPI_Raccumulate</A></TD>
|
||||
<TD><A HREF="www3/MPI_Win_set_name.html">MPI_Win_set_name</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_File_read_at_all_begin.html">MPI_File_read_at_all_begin</A></TD>
|
||||
<TD><A HREF="www3/MPI_Reduce_local.html">MPI_Reduce_local</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_File_read.html">MPI_File_read</A></TD>
|
||||
<TD><A HREF="www3/MPI_Recv.html">MPI_Recv</A></TD>
|
||||
<TD><A HREF="www3/MPI_Win_shared_query.html">MPI_Win_shared_query</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_File_read_at_all_end.html">MPI_File_read_at_all_end</A></TD>
|
||||
<TD><A HREF="www3/MPI_Reduce_scatter.html">MPI_Reduce_scatter</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_File_read_all.html">MPI_File_read_all</A></TD>
|
||||
<TD><A HREF="www3/MPI_Recv_init.html">MPI_Recv_init</A></TD>
|
||||
<TD><A HREF="www3/MPI_Win_start.html">MPI_Win_start</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_File_read_ordered.html">MPI_File_read_ordered</A></TD>
|
||||
<TD><A HREF="www3/MPI_Reduce_scatter_block.html">MPI_Reduce_scatter_block</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_File_read_all_begin.html">MPI_File_read_all_begin</A></TD>
|
||||
<TD><A HREF="www3/MPI_Reduce.html">MPI_Reduce</A></TD>
|
||||
<TD><A HREF="www3/MPI_Win_sync.html">MPI_Win_sync</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_File_read_ordered_begin.html">MPI_File_read_ordered_begin</A></TD>
|
||||
<TD><A HREF="www3/MPI_Register_datarep.html">MPI_Register_datarep</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_File_read_all_end.html">MPI_File_read_all_end</A></TD>
|
||||
<TD><A HREF="www3/MPI_Reduce_local.html">MPI_Reduce_local</A></TD>
|
||||
<TD><A HREF="www3/MPI_Win_test.html">MPI_Win_test</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_File_read_ordered_end.html">MPI_File_read_ordered_end</A></TD>
|
||||
<TD><A HREF="www3/MPI_Request_free.html">MPI_Request_free</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_File_read_at.html">MPI_File_read_at</A></TD>
|
||||
<TD><A HREF="www3/MPI_Reduce_scatter.html">MPI_Reduce_scatter</A></TD>
|
||||
<TD><A HREF="www3/MPI_Win_unlock.html">MPI_Win_unlock</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_File_read_shared.html">MPI_File_read_shared</A></TD>
|
||||
<TD><A HREF="www3/MPI_Request_get_status.html">MPI_Request_get_status</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_File_read_at_all.html">MPI_File_read_at_all</A></TD>
|
||||
<TD><A HREF="www3/MPI_Reduce_scatter_block.html">MPI_Reduce_scatter_block</A></TD>
|
||||
<TD><A HREF="www3/MPI_Win_unlock_all.html">MPI_Win_unlock_all</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_File_seek.html">MPI_File_seek</A></TD>
|
||||
<TD><A HREF="www3/MPI_Rget.html">MPI_Rget</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_File_read_at_all_begin.html">MPI_File_read_at_all_begin</A></TD>
|
||||
<TD><A HREF="www3/MPI_Register_datarep.html">MPI_Register_datarep</A></TD>
|
||||
<TD><A HREF="www3/MPI_Win_wait.html">MPI_Win_wait</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_File_seek_shared.html">MPI_File_seek_shared</A></TD>
|
||||
<TD><A HREF="www3/MPI_Rget_accumulate.html">MPI_Rget_accumulate</A></TD>
|
||||
<TR><TD><A HREF="www3/MPI_File_read_at_all_end.html">MPI_File_read_at_all_end</A></TD>
|
||||
<TD><A HREF="www3/MPI_Request_free.html">MPI_Request_free</A></TD>
|
||||
<TD><A HREF="www3/MPI_Wtick.html">MPI_Wtick</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_File_read_ordered.html">MPI_File_read_ordered</A></TD>
|
||||
<TD><A HREF="www3/MPI_Request_get_status.html">MPI_Request_get_status</A></TD>
|
||||
<TD><A HREF="www3/MPI_Wtime.html">MPI_Wtime</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www3/MPI_File_read_ordered_begin.html">MPI_File_read_ordered_begin</A></TD>
|
||||
<TD><A HREF="www3/MPI_Rget.html">MPI_Rget</A></TD>
|
||||
<TD></TD>
|
||||
</TR>
|
||||
</TABLE>
|
||||
</BODY>
|
||||
</HTML>
|
||||
|
||||
Binary file not shown.
Binary file not shown.
Binary file not shown.
@@ -22,12 +22,12 @@ running them
|
||||
|
||||
<DT><B>-help </B><DD>Give short help
|
||||
|
||||
<DT><B>-cc=name </B><DD>Use compiler <tt>name</tt> instead of the default choice. Use
|
||||
<DT><B>-cc=name </B><DD>Use compiler <TT>name</TT> instead of the default choice. Use
|
||||
this only if the compiler is compatible with the MPICH
|
||||
library (see below)
|
||||
|
||||
<DT><B>-config=name </B><DD>Load a configuration file for a particular compiler.
|
||||
This allows a single <tt>mpicc</tt> command to be used with
|
||||
This allows a single <TT>mpicc</TT> command to be used with
|
||||
multiple compilers.
|
||||
|
||||
<DT><B>-compile_info </B><DD>Show the steps for compiling a program. This option
|
||||
@@ -44,37 +44,40 @@ details
|
||||
<DT><B>-echo </B><DD>Show exactly what this program is doing.
|
||||
This option should normally not be used.
|
||||
|
||||
<DT><B>others </B><DD>are passed to the compiler or linker. For example, <tt>\-c
|
||||
</tt>causes files to be compiled, <tt>\-g</tt> selects compilation with
|
||||
debugging on most systems, and <tt>\-o name</tt> causes linking
|
||||
with the output executable given the name <tt>name</tt>.
|
||||
<DT><B>-static</B><DD>mpi - Use a statically compile MPI library, but shared libraries
|
||||
for all of the other dependencies.
|
||||
|
||||
<DT><B>others </B><DD>are passed to the compiler or linker. For example, <TT>\-c
|
||||
</TT>causes files to be compiled, <TT>\-g</TT> selects compilation with
|
||||
debugging on most systems, and <TT>\-o name</TT> causes linking
|
||||
with the output executable given the name <TT>name</TT>.
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Environment Variables</H2>
|
||||
The environment variable <tt>MPICH_CC</tt> may be used
|
||||
The environment variable <TT>MPICH_CC</TT> may be used
|
||||
to select different C compiler and linker. Note that since
|
||||
MPICH is built with a particular C and Fortran compiler, changing the
|
||||
compilers used can cause problems. Use this only if you could intermix
|
||||
code compiled with the different compilers.
|
||||
<P>
|
||||
The environment variable <tt>MPICC_PROFILE</tt> specifies a profile library
|
||||
and has the same effect as if <tt>\-profile=$MPICC_PROFILE</tt> were used as
|
||||
an argument to <tt>mpicc</tt>. See the discussion of <tt>\-profile</tt> below for more
|
||||
The environment variable <TT>MPICC_PROFILE</TT> specifies a profile library
|
||||
and has the same effect as if <TT>\-profile=$MPICC_PROFILE</TT> were used as
|
||||
an argument to <TT>mpicc</TT>. See the discussion of <TT>\-profile</TT> below for more
|
||||
details.
|
||||
<P>
|
||||
<H2>Compatible Compilers</H2>
|
||||
The MPI library may be used with any compiler that uses the same
|
||||
lengths for basic data objects (such as <tt>long double</tt>) and that
|
||||
lengths for basic data objects (such as <TT>long double</TT>) and that
|
||||
uses compatible run-time libraries. On many systems, the various
|
||||
compilers are compatible and may be used interchangably. There are
|
||||
exceptions; if you use the <tt>MPICH_CC</tt> environment variable or the
|
||||
<tt>\-cc=name</tt> command-line argument to override the choice of compiler
|
||||
exceptions; if you use the <TT>MPICH_CC</TT> environment variable or the
|
||||
<TT>\-cc=name</TT> command-line argument to override the choice of compiler
|
||||
and encounter problems, try reconfiguring MPICH with the new compiler
|
||||
and installing MPICH in a separate location. See the installation manual
|
||||
for more details.
|
||||
<P>
|
||||
<H2>Examples</H2>
|
||||
To compile a single file <tt>foo.c</tt>, use
|
||||
To compile a single file <TT>foo.c</TT>, use
|
||||
<PRE>
|
||||
mpicc -c foo.c
|
||||
</PRE>
|
||||
@@ -93,19 +96,19 @@ Combining compilation and linking in a single command
|
||||
is a convenient way to build simple programs.
|
||||
<P>
|
||||
<H2>Selecting a Profiling Library</H2>
|
||||
The <tt>\-profile=name</tt> argument allows you to specify an MPI profiling
|
||||
library to be used. <tt>name</tt> can have two forms:
|
||||
The <TT>\-profile=name</TT> argument allows you to specify an MPI profiling
|
||||
library to be used. <TT>name</TT> can have two forms:
|
||||
<P>
|
||||
<br>A library in the same directory as the MPI library
|
||||
<br>The name of a profile configuration file
|
||||
<br>
|
||||
<BR>A library in the same directory as the MPI library
|
||||
<BR>The name of a profile configuration file
|
||||
<BR>
|
||||
<P>
|
||||
If <tt>name</tt> is a library, then this library is included before the MPI
|
||||
If <TT>name</TT> is a library, then this library is included before the MPI
|
||||
library. This allows the simple use of libraries that make use of the
|
||||
MPI profiling interface and that are installed in the same directory as
|
||||
the MPI library.
|
||||
<P>
|
||||
If <tt>name.conf</tt> is the name of a file in the sysconfdir directory, then this
|
||||
If <TT>name.conf</TT> is the name of a file in the sysconfdir directory, then this
|
||||
is read and may define the following variables:
|
||||
<DL>
|
||||
<DT><B>PROFILE_PRELIB </B><DD>Libraries (and paths) to include before the MPI library
|
||||
@@ -113,9 +116,9 @@ is read and may define the following variables:
|
||||
<DT><B>PROFILE_POSTLIB </B><DD>Libraries to include after the MPI library
|
||||
|
||||
<DT><B>PROFILE_INCPATHS </B><DD>C preprocessor arguments for any include files
|
||||
For example, to add <tt>/usr/local/myprof/include</tt> to the include path and
|
||||
the library <tt>libmyprof.a</tt> in <tt>/usr/local/myprof/lib</tt> to the link step,
|
||||
you could create the file <tt>myprof.conf</tt> with the lines
|
||||
For example, to add <TT>/usr/local/myprof/include</TT> to the include path and
|
||||
the library <TT>libmyprof.a</TT> in <TT>/usr/local/myprof/lib</TT> to the link step,
|
||||
you could create the file <TT>myprof.conf</TT> with the lines
|
||||
</DL>
|
||||
<P>
|
||||
<PRE>
|
||||
@@ -125,10 +128,10 @@ you could create the file <tt>myprof.conf</tt> with the lines
|
||||
|
||||
and place it in the sysconfdir directory (this directory is set at
|
||||
configure time when MPICH is built). Then using the command-line
|
||||
argument <tt>\-profile=myprof</tt> will cause these
|
||||
argument <TT>\-profile=myprof</TT> will cause these
|
||||
definitions to be added to the relevant compile commands.
|
||||
<P>
|
||||
<H0>See Also</H0>
|
||||
<H2>See Also</H2>
|
||||
mpicxx, mpifort, mpiexec
|
||||
<br>
|
||||
<BR>
|
||||
</BODY></HTML>
|
||||
|
||||
@@ -22,12 +22,12 @@ running them
|
||||
|
||||
<DT><B>-help </B><DD>Give short help
|
||||
|
||||
<DT><B>-cxx=name </B><DD>Use compiler <tt>name</tt> instead of the default choice. Use
|
||||
<DT><B>-cxx=name </B><DD>Use compiler <TT>name</TT> instead of the default choice. Use
|
||||
this only if the compiler is compatible with the MPICH
|
||||
library (see below)
|
||||
|
||||
<DT><B>-config=name </B><DD>Load a configuration file for a particular compiler.
|
||||
This allows a single <tt>mpicxx</tt> command to be used with
|
||||
This allows a single <TT>mpicxx</TT> command to be used with
|
||||
multiple compilers.
|
||||
|
||||
<DT><B>-compile_info </B><DD>Show the steps for compiling a program. This option
|
||||
@@ -44,37 +44,40 @@ details
|
||||
<DT><B>-echo </B><DD>Show exactly what this program is doing.
|
||||
This option should normally not be used.
|
||||
|
||||
<DT><B>others </B><DD>are passed to the compiler or linker. For example, <tt>\-c
|
||||
</tt>causes files to be compiled, <tt>\-g</tt> selects compilation with
|
||||
debugging on most systems, and <tt>\-o name</tt> causes linking
|
||||
with the output executable given the name <tt>name</tt>.
|
||||
<DT><B>-static</B><DD>mpi - Use a statically compile MPI library, but shared libraries
|
||||
for all of the other dependencies.
|
||||
|
||||
<DT><B>others </B><DD>are passed to the compiler or linker. For example, <TT>\-c
|
||||
</TT>causes files to be compiled, <TT>\-g</TT> selects compilation with
|
||||
debugging on most systems, and <TT>\-o name</TT> causes linking
|
||||
with the output executable given the name <TT>name</TT>.
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Environment Variables</H2>
|
||||
The environment variables <tt>MPICH_CXX</tt> may be used
|
||||
The environment variables <TT>MPICH_CXX</TT> may be used
|
||||
to select different C++ compiler and linker. Note that since
|
||||
MPICH is built with a particular C and Fortran compiler, changing the
|
||||
compilers used can cause problems. Use this only if you could intermix
|
||||
code compiled with the different compilers.
|
||||
<P>
|
||||
The environment variable <tt>MPICC_PROFILE</tt> specifies a profile library
|
||||
and has the same effect as if <tt>\-profile=$MPICC_PROFILE</tt> were used as
|
||||
an argument to <tt>mpicc</tt>. See the discussion of <tt>\-profile</tt> below for more
|
||||
The environment variable <TT>MPICC_PROFILE</TT> specifies a profile library
|
||||
and has the same effect as if <TT>\-profile=$MPICC_PROFILE</TT> were used as
|
||||
an argument to <TT>mpicc</TT>. See the discussion of <TT>\-profile</TT> below for more
|
||||
details.
|
||||
<P>
|
||||
<H2>Compatible Compilers</H2>
|
||||
The MPI library may be used with any compiler that uses the same
|
||||
lengths for basic data objects (such as <tt>long double</tt>) and that
|
||||
lengths for basic data objects (such as <TT>long double</TT>) and that
|
||||
uses compatible run-time libraries. On many systems, the various
|
||||
compilers are compatible and may be used interchangably. There are
|
||||
exceptions; if you use the <tt>MPICH_CXX</tt> environment variable or the
|
||||
<tt>\-cxx=name</tt> command-line argument to override the choice of compiler
|
||||
exceptions; if you use the <TT>MPICH_CXX</TT> environment variable or the
|
||||
<TT>\-cxx=name</TT> command-line argument to override the choice of compiler
|
||||
and encounter problems, try reconfiguring MPICH with the new compiler,
|
||||
and installing MPICH in a separate location. See the installation manual
|
||||
for more details.
|
||||
<P>
|
||||
<H2>Examples</H2>
|
||||
To compile a single file <tt>foo.c</tt>, use
|
||||
To compile a single file <TT>foo.c</TT>, use
|
||||
<PRE>
|
||||
mpicxx -c foo.cxx
|
||||
</PRE>
|
||||
@@ -93,19 +96,19 @@ Combining compilation and linking in a single command
|
||||
is a convenient way to build simple programs.
|
||||
<P>
|
||||
<H2>Selecting a Profiling Library</H2>
|
||||
The <tt>\-profile=name</tt> argument allows you to specify an MPI profiling
|
||||
library to be used. <tt>name</tt> can have two forms:
|
||||
The <TT>\-profile=name</TT> argument allows you to specify an MPI profiling
|
||||
library to be used. <TT>name</TT> can have two forms:
|
||||
<P>
|
||||
<br>A library in the same directory as the MPI library
|
||||
<br>The name of a profile configuration file
|
||||
<br>
|
||||
<BR>A library in the same directory as the MPI library
|
||||
<BR>The name of a profile configuration file
|
||||
<BR>
|
||||
<P>
|
||||
If <tt>name</tt> is a library, then this library is included before the MPI
|
||||
If <TT>name</TT> is a library, then this library is included before the MPI
|
||||
library. This allows the simple use of libraries that make use of the
|
||||
MPI profiling interface and that are installed in the same directory as
|
||||
the MPI library.
|
||||
<P>
|
||||
If <tt>name.conf</tt> is the name of a file in the sysconfdir directory, then this
|
||||
If <TT>name.conf</TT> is the name of a file in the sysconfdir directory, then this
|
||||
is read and may define the following variables:
|
||||
<DL>
|
||||
<DT><B>PROFILE_PRELIB </B><DD>Libraries (and paths) to include before the MPI library
|
||||
@@ -113,9 +116,9 @@ is read and may define the following variables:
|
||||
<DT><B>PROFILE_POSTLIB </B><DD>Libraries to include after the MPI library
|
||||
|
||||
<DT><B>PROFILE_INCPATHS </B><DD>C preprocessor arguments for any include files
|
||||
For example, to add <tt>/usr/local/myprof/include</tt> to the include path and
|
||||
the library <tt>libmyprof.a</tt> in <tt>/usr/local/myprof/lib</tt> to the link step,
|
||||
you could create the file <tt>myprof.conf</tt> with the lines
|
||||
For example, to add <TT>/usr/local/myprof/include</TT> to the include path and
|
||||
the library <TT>libmyprof.a</TT> in <TT>/usr/local/myprof/lib</TT> to the link step,
|
||||
you could create the file <TT>myprof.conf</TT> with the lines
|
||||
</DL>
|
||||
<P>
|
||||
<PRE>
|
||||
@@ -125,10 +128,10 @@ you could create the file <tt>myprof.conf</tt> with the lines
|
||||
|
||||
and place it in the sysconfdir directory (this directory is set at
|
||||
configure time when MPICH is built). Then using the command-line
|
||||
argument <tt>\-profile=myprof</tt> will cause these
|
||||
argument <TT>\-profile=myprof</TT> will cause these
|
||||
definitions to be added to the relevant compile commands.
|
||||
<P>
|
||||
<H0>See Also</H0>
|
||||
<H2>See Also</H2>
|
||||
mpicc, mpifort, mpiexec
|
||||
<br>
|
||||
<BR>
|
||||
</BODY></HTML>
|
||||
|
||||
@@ -14,12 +14,12 @@ Run an MPI program
|
||||
mpiexec args executable pgmargs [ : args executable pgmargs ... ]
|
||||
</PRE>
|
||||
|
||||
where <tt>args</tt> are command line arguments for <tt>mpiexec</tt> (see below),
|
||||
<tt>executable</tt> is the name of an executable MPI program, and <tt>pgmargs
|
||||
</tt>are command line arguments for the executable. Multiple executables
|
||||
where <TT>args</TT> are command line arguments for <TT>mpiexec</TT> (see below),
|
||||
<TT>executable</TT> is the name of an executable MPI program, and <TT>pgmargs
|
||||
</TT>are command line arguments for the executable. Multiple executables
|
||||
can be specified by using the colon notation (for MPMD - Multiple Program
|
||||
Multiple Data applications). For example, the following command will run
|
||||
the MPI program <tt>a.out</tt> on 4 processes:
|
||||
the MPI program <TT>a.out</TT> on 4 processes:
|
||||
<PRE>
|
||||
mpiexec -n 4 a.out
|
||||
</PRE>
|
||||
@@ -34,7 +34,7 @@ The MPI standard specifies the following arguments and their meanings:
|
||||
|
||||
<DT><B>-arch <architecture name> </B><DD>Pick hosts with this architecture type
|
||||
|
||||
<DT><B>-wdir <working directory> </B><DD>cd to this one <em>before</em> running executable
|
||||
<DT><B>-wdir <working directory> </B><DD>cd to this one <EM>before</EM> running executable
|
||||
|
||||
<DT><B>-path <pathlist> </B><DD>use this to find the executable
|
||||
|
||||
@@ -53,13 +53,13 @@ Additional arguments that are specific to the MPICH implementation
|
||||
are discussed below.
|
||||
<P>
|
||||
Note that not all of these parameters are meaningful for all
|
||||
systems. For example, the <tt>gforker</tt> version of <tt>mpiexec</tt> creates all
|
||||
systems. For example, the <TT>gforker</TT> version of <TT>mpiexec</TT> creates all
|
||||
processes on the same system on which it is running; in that case, the
|
||||
<tt>\-arch</tt> and <tt>\-host</tt> options are ignored.
|
||||
<TT>\-arch</TT> and <TT>\-host</TT> options are ignored.
|
||||
<P>
|
||||
The colon character (<tt>:</tt>) may be used to separate different executables
|
||||
The colon character (<TT>:</TT>) may be used to separate different executables
|
||||
for MPMD (multiple program multiple data) programming. For example,
|
||||
to run the program <tt>ocean</tt> on 4 processes and <tt>air</tt> on 8 processes, use:
|
||||
to run the program <TT>ocean</TT> on 4 processes and <TT>air</TT> on 8 processes, use:
|
||||
<P>
|
||||
<PRE>
|
||||
mpiexec -n 4 ocean : -n 8 air
|
||||
@@ -70,40 +70,40 @@ to run the program <tt>ocean</tt> on 4 processes and <tt>air</tt> on 8 processes
|
||||
<H2>MPICH-Specific Arguments</H2>
|
||||
<P>
|
||||
Many of the implementations of process managers in MPICH support the
|
||||
following arguments to <tt>mpiexec</tt>:
|
||||
following arguments to <TT>mpiexec</TT>:
|
||||
<P>
|
||||
<DL>
|
||||
<DT><B>-np <num> </B><DD>A synonym for the standard <tt>\-n</tt> argument
|
||||
<DT><B>-np <num> </B><DD>A synonym for the standard <TT>\-n</TT> argument
|
||||
|
||||
<DT><B>-env <name> <value> </B><DD>Set the environment variable <tt><name></tt> to <tt><value></tt> for
|
||||
the processes being run by <tt>mpiexec
|
||||
</tt>
|
||||
<DT><B>-env <name> <value> </B><DD>Set the environment variable <TT><name></TT> to <TT><value></TT> for
|
||||
the processes being run by <TT>mpiexec
|
||||
</TT>
|
||||
<DT><B>-envnone </B><DD>Pass no environment variables (other than ones specified with
|
||||
other <tt>\-env</tt> or <tt>\-genv</tt> arguments) to the processes being run by <tt>mpiexec</tt>.
|
||||
other <TT>\-env</TT> or <TT>\-genv</TT> arguments) to the processes being run by <TT>mpiexec</TT>.
|
||||
By default, all environment
|
||||
variables are provided to each MPI process (rationale: principle of
|
||||
least surprise for the user)
|
||||
|
||||
<DT><B>-envlist <list> </B><DD>Pass the listed environment variables (names separated
|
||||
by commas), with their current values, to the processes being run by
|
||||
<tt>mpiexec</tt>.
|
||||
<TT>mpiexec</TT>.
|
||||
|
||||
<DT><B>-genv <name> <value> </B><DD>The <tt>\-genv</tt> options have the same meaning as their
|
||||
corresponding <tt>\-env</tt> version, except they apply to all executables, not just
|
||||
<DT><B>-genv <name> <value> </B><DD>The <TT>\-genv</TT> options have the same meaning as their
|
||||
corresponding <TT>\-env</TT> version, except they apply to all executables, not just
|
||||
the current executable (in the case that the colon syntax is used to specify
|
||||
multiple execuables).
|
||||
|
||||
<DT><B>-genvnone </B><DD>Like <tt>\-envnone</tt>, but for all executables
|
||||
<DT><B>-genvnone </B><DD>Like <TT>\-envnone</TT>, but for all executables
|
||||
|
||||
<DT><B>-genvlist <list> </B><DD>Like <tt>\-envlist</tt>, but for all executables
|
||||
<DT><B>-genvlist <list> </B><DD>Like <TT>\-envlist</TT>, but for all executables
|
||||
|
||||
<DT><B>-usize <n> </B><DD>Specify the value returned for the value of the attribute
|
||||
<tt>MPI_UNIVERSE_SIZE</tt>.
|
||||
<TT>MPI_UNIVERSE_SIZE</TT>.
|
||||
|
||||
<DT><B>-l </B><DD>Label standard out and standard error (<tt>stdout</tt> and <tt>stderr</tt>) with
|
||||
<DT><B>-l </B><DD>Label standard out and standard error (<TT>stdout</TT> and <TT>stderr</TT>) with
|
||||
the rank of the process
|
||||
|
||||
<DT><B>-maxtime <n> </B><DD>Set a timelimit of <tt><n></tt> seconds.
|
||||
<DT><B>-maxtime <n> </B><DD>Set a timelimit of <TT><n></TT> seconds.
|
||||
|
||||
<DT><B>-exitinfo </B><DD>Provide more information on the reason each process exited if
|
||||
there is an abnormal exit
|
||||
@@ -111,42 +111,42 @@ there is an abnormal exit
|
||||
<P>
|
||||
<H2>Environment variables for mpiexec</H2>
|
||||
The following environment variables are understood by some versions of
|
||||
<tt>mpiexec</tt>. The command line arguments have priority over these; that is,
|
||||
<TT>mpiexec</TT>. The command line arguments have priority over these; that is,
|
||||
if both the environment variable and command line argument are used, the
|
||||
value specified by the command line argument is used.
|
||||
<P>
|
||||
<DL>
|
||||
<DT><B>MPIEXEC_TIMEOUT </B><DD>Maximum running time in seconds. <tt>mpiexec</tt> will
|
||||
<DT><B>MPIEXEC_TIMEOUT </B><DD>Maximum running time in seconds. <TT>mpiexec</TT> will
|
||||
terminate MPI programs that take longer than the value specified by
|
||||
<tt>MPIEXEC_TIMEOUT</tt>.
|
||||
<TT>MPIEXEC_TIMEOUT</TT>.
|
||||
|
||||
<DT><B>MPIEXEC_UNIVERSE_SIZE </B><DD>Set the universe size
|
||||
|
||||
<DT><B>MPIEXEC_PORT_RANGE </B><DD>Set the range of ports that <tt>mpiexec</tt> will use
|
||||
<DT><B>MPIEXEC_PORT_RANGE </B><DD>Set the range of ports that <TT>mpiexec</TT> will use
|
||||
in communicating with the processes that it starts. The format of
|
||||
this is <tt><low>:<high></tt>. For example, to specify any port between
|
||||
10000 and 10100, use <tt>10000:10100</tt>.
|
||||
this is <TT><low>:<high></TT>. For example, to specify any port between
|
||||
10000 and 10100, use <TT>10000:10100</TT>.
|
||||
|
||||
<DT><B>MPICH_PORT_RANGE </B><DD>Has the same meaning as <tt>MPIEXEC_PORT_RANGE</tt> and
|
||||
is used if <tt>MPIEXEC_PORT_RANGE</tt> is not set.
|
||||
<DT><B>MPICH_PORT_RANGE </B><DD>Has the same meaning as <TT>MPIEXEC_PORT_RANGE</TT> and
|
||||
is used if <TT>MPIEXEC_PORT_RANGE</TT> is not set.
|
||||
|
||||
<DT><B>MPIEXEC_PREFIX_DEFAULT </B><DD>If this environment variable is set, output
|
||||
to standard output is prefixed by the rank in <tt>MPI_COMM_WORLD</tt> of the
|
||||
to standard output is prefixed by the rank in <TT>MPI_COMM_WORLD</TT> of the
|
||||
process and output to standard error is prefixed by the rank and the
|
||||
text <tt>(err)</tt>; both are followed by an angle bracket (<tt>></tt>). If
|
||||
text <TT>(err)</TT>; both are followed by an angle bracket (<TT>></TT>). If
|
||||
this variable is not set, there is no prefix.
|
||||
|
||||
<DT><B>MPIEXEC_PREFIX_STDOUT </B><DD>Set the prefix used for lines sent to standard
|
||||
output. A <tt>%d</tt> is replaced with the rank in <tt>MPI_COMM_WORLD</tt>; a <tt>%w</tt> is
|
||||
replaced with an indication of which <tt>MPI_COMM_WORLD</tt> in MPI jobs that
|
||||
involve multiple <tt>MPI_COMM_WORLD</tt>s (e.g., ones that use <tt>MPI_Comm_spawn</tt> or
|
||||
<tt>MPI_Comm_connect</tt>).
|
||||
output. A <TT>%d</TT> is replaced with the rank in <TT>MPI_COMM_WORLD</TT>; a <TT>%w</TT> is
|
||||
replaced with an indication of which <TT>MPI_COMM_WORLD</TT> in MPI jobs that
|
||||
involve multiple <TT>MPI_COMM_WORLD</TT>s (e.g., ones that use <TT>MPI_Comm_spawn</TT> or
|
||||
<TT>MPI_Comm_connect</TT>).
|
||||
|
||||
<DT><B>MPIEXEC_PREFIX_STDERR </B><DD>Like <tt>MPIEXEC_PREFIX_STDOUT</tt>, but for standard error.
|
||||
<DT><B>MPIEXEC_PREFIX_STDERR </B><DD>Like <TT>MPIEXEC_PREFIX_STDOUT</TT>, but for standard error.
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Return Status</H2>
|
||||
<tt>mpiexec</tt> returns the maximum of the exit status values of all of the
|
||||
processes created by <tt>mpiexec</tt>.
|
||||
<TT>mpiexec</TT> returns the maximum of the exit status values of all of the
|
||||
processes created by <TT>mpiexec</TT>.
|
||||
<P>
|
||||
</BODY></HTML>
|
||||
|
||||
@@ -22,12 +22,12 @@ running them
|
||||
|
||||
<DT><B>-help </B><DD>Give short help
|
||||
|
||||
<DT><B>-f77=name </B><DD>Use compiler <tt>name</tt> instead of the default choice. Use
|
||||
<DT><B>-f77=name </B><DD>Use compiler <TT>name</TT> instead of the default choice. Use
|
||||
this only if the compiler is compatible with the MPICH
|
||||
library (see below)
|
||||
|
||||
<DT><B>-config=name </B><DD>Load a configuration file for a particular compiler.
|
||||
This allows a single <tt>mpif77</tt> command to be used with
|
||||
This allows a single <TT>mpif77</TT> command to be used with
|
||||
multiple compilers.
|
||||
|
||||
<DT><B>-compile_info </B><DD>Show the steps for compiling a program. This option
|
||||
@@ -44,14 +44,17 @@ details
|
||||
<DT><B>-echo </B><DD>Show exactly what this program is doing.
|
||||
This option should normally not be used.
|
||||
|
||||
<DT><B>others </B><DD>are passed to the compiler or linker. For example, <tt>\-c
|
||||
</tt>causes files to be compiled, <tt>\-g</tt> selects compilation with
|
||||
debugging on most systems, and <tt>\-o name</tt> causes linking
|
||||
with the output executable given the name <tt>name</tt>.
|
||||
<DT><B>-static</B><DD>mpi - Use a statically compile MPI library, but shared libraries
|
||||
for all of the other dependencies.
|
||||
|
||||
<DT><B>others </B><DD>are passed to the compiler or linker. For example, <TT>\-c
|
||||
</TT>causes files to be compiled, <TT>\-g</TT> selects compilation with
|
||||
debugging on most systems, and <TT>\-o name</TT> causes linking
|
||||
with the output executable given the name <TT>name</TT>.
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Environment Variables</H2>
|
||||
The environment variables <tt>MPICH_F77</tt> may be used
|
||||
The environment variables <TT>MPICH_F77</TT> may be used
|
||||
to select different Fortran compiler and linker. Note that since
|
||||
MPICH is built with a particular C and Fortran compiler, change the
|
||||
compilers used can cause problems. Use this only if you could intermix
|
||||
@@ -59,17 +62,17 @@ code compiled with the different compilers.
|
||||
<P>
|
||||
<H2>Compatible Compilers</H2>
|
||||
The MPI library may be used with any compiler that uses the same
|
||||
lengths for basic data objects (such as <tt>long double</tt>) and that
|
||||
lengths for basic data objects (such as <TT>long double</TT>) and that
|
||||
uses compatible run-time libraries. On many systems, the various
|
||||
compilers are compatible and may be used interchangably. There are
|
||||
exceptions; if you use the <tt>MPICH_F77</tt> environment variable or the
|
||||
<tt>\-f77=name</tt> command-line argument to override the choice of compiler
|
||||
exceptions; if you use the <TT>MPICH_F77</TT> environment variable or the
|
||||
<TT>\-f77=name</TT> command-line argument to override the choice of compiler
|
||||
and encounter problems, try reconfiguring MPICH with the new compiler
|
||||
and installing MPICH in a separate location. See the installation manual
|
||||
for more details.
|
||||
<P>
|
||||
<H2>Examples</H2>
|
||||
To compile a single file <tt>foo.f</tt>, use
|
||||
To compile a single file <TT>foo.f</TT>, use
|
||||
<PRE>
|
||||
mpif77 -c foo.f
|
||||
</PRE>
|
||||
@@ -88,19 +91,19 @@ Combining compilation and linking in a single command
|
||||
is a convenient way to build simple programs.
|
||||
<P>
|
||||
<H2>Selecting a Profiling Library</H2>
|
||||
The <tt>\-profile=name</tt> argument allows you to specify an MPI profiling
|
||||
library to be used. <tt>name</tt> can have two forms:
|
||||
The <TT>\-profile=name</TT> argument allows you to specify an MPI profiling
|
||||
library to be used. <TT>name</TT> can have two forms:
|
||||
<P>
|
||||
<br>A library in the same directory as the MPI library
|
||||
<br>The name of a profile configuration file
|
||||
<br>
|
||||
<BR>A library in the same directory as the MPI library
|
||||
<BR>The name of a profile configuration file
|
||||
<BR>
|
||||
<P>
|
||||
If <tt>name</tt> is a library, then this library is included before the MPI
|
||||
If <TT>name</TT> is a library, then this library is included before the MPI
|
||||
library. This allows the simple use of libraries that make use of the
|
||||
MPI profiling interface and that are installed in the same directory as
|
||||
the MPI library.
|
||||
<P>
|
||||
If <tt>name.conf</tt> is the name of a file in the sysconfdir directory, then this
|
||||
If <TT>name.conf</TT> is the name of a file in the sysconfdir directory, then this
|
||||
is read and may define the following variables:
|
||||
<DL>
|
||||
<DT><B>PROFILE_PRELIB </B><DD>Libraries (and paths) to include before the MPI library
|
||||
@@ -108,9 +111,9 @@ is read and may define the following variables:
|
||||
<DT><B>PROFILE_POSTLIB </B><DD>Libraries to include after the MPI library
|
||||
|
||||
<DT><B>PROFILE_INCPATHS </B><DD>C preprocessor arguments for any include files
|
||||
For example, to add <tt>/usr/local/myprof/include</tt> to the include path and
|
||||
the library <tt>libmyprof.a</tt> in <tt>/usr/local/myprof/lib</tt> to the link step,
|
||||
you could create the file <tt>myprof.conf</tt> with the lines
|
||||
For example, to add <TT>/usr/local/myprof/include</TT> to the include path and
|
||||
the library <TT>libmyprof.a</TT> in <TT>/usr/local/myprof/lib</TT> to the link step,
|
||||
you could create the file <TT>myprof.conf</TT> with the lines
|
||||
</DL>
|
||||
<P>
|
||||
<PRE>
|
||||
@@ -120,10 +123,10 @@ you could create the file <tt>myprof.conf</tt> with the lines
|
||||
|
||||
and place it in the sysconfdir directory (this directory is set at
|
||||
configure time when MPICH is built). Then using the command-line
|
||||
argument <tt>\-profile=myprof</tt> will cause these
|
||||
argument <TT>\-profile=myprof</TT> will cause these
|
||||
definitions to be added to the relevant compile commands.
|
||||
<P>
|
||||
<H0>See Also</H0>
|
||||
<H2>See Also</H2>
|
||||
mpicc, mpicxx, mpifort, mpiexec
|
||||
<br>
|
||||
<BR>
|
||||
</BODY></HTML>
|
||||
|
||||
@@ -22,12 +22,12 @@ running them
|
||||
|
||||
<DT><B>-help </B><DD>Give short help
|
||||
|
||||
<DT><B>-fc=name </B><DD>Use compiler <tt>name</tt> instead of the default choice. Use
|
||||
<DT><B>-fc=name </B><DD>Use compiler <TT>name</TT> instead of the default choice. Use
|
||||
this only if the compiler is compatible with the MPICH
|
||||
library (see below)
|
||||
|
||||
<DT><B>-config=name </B><DD>Load a configuration file for a particular compiler.
|
||||
This allows a single <tt>mpifort</tt> command to be used with
|
||||
This allows a single <TT>mpifort</TT> command to be used with
|
||||
multiple compilers.
|
||||
|
||||
<DT><B>-compile_info </B><DD>Show the steps for compiling a program. This option
|
||||
@@ -44,14 +44,17 @@ details
|
||||
<DT><B>-echo </B><DD>Show exactly what this program is doing.
|
||||
This option should normally not be used.
|
||||
|
||||
<DT><B>others </B><DD>are passed to the compiler or linker. For example, <tt>\-c
|
||||
</tt>causes files to be compiled, <tt>\-g</tt> selects compilation with
|
||||
debugging on most systems, and <tt>\-o name</tt> causes linking
|
||||
with the output executable given the name <tt>name</tt>.
|
||||
<DT><B>-static</B><DD>mpi - Use a statically compile MPI library, but shared libraries
|
||||
for all of the other dependencies.
|
||||
|
||||
<DT><B>others </B><DD>are passed to the compiler or linker. For example, <TT>\-c
|
||||
</TT>causes files to be compiled, <TT>\-g</TT> selects compilation with
|
||||
debugging on most systems, and <TT>\-o name</TT> causes linking
|
||||
with the output executable given the name <TT>name</TT>.
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Environment Variables</H2>
|
||||
The environment variables <tt>MPICH_FC</tt> may be used
|
||||
The environment variables <TT>MPICH_FC</TT> may be used
|
||||
to select different Fortran compiler and linker. Note that since
|
||||
MPICH is built with a particular C and Fortran compiler, change the
|
||||
compilers used can cause problems. Use this only if you could intermix
|
||||
@@ -59,17 +62,17 @@ code compiled with the different compilers.
|
||||
<P>
|
||||
<H2>Compatible Compilers</H2>
|
||||
The MPI library may be used with any compiler that uses the same
|
||||
lengths for basic data objects (such as <tt>long double</tt>) and that
|
||||
lengths for basic data objects (such as <TT>long double</TT>) and that
|
||||
uses compatible run-time libraries. On many systems, the various
|
||||
compilers are compatible and may be used interchangably. There are
|
||||
exceptions; if you use the <tt>MPICH_FC</tt> environment variable or the
|
||||
<tt>\-fc=name</tt> command-line argument to override the choice of compiler
|
||||
exceptions; if you use the <TT>MPICH_FC</TT> environment variable or the
|
||||
<TT>\-fc=name</TT> command-line argument to override the choice of compiler
|
||||
and encounter problems, try reconfiguring MPICH with the new compiler
|
||||
and installing MPICH in a separate location. See the installation manual
|
||||
for more details.
|
||||
<P>
|
||||
<H2>Examples</H2>
|
||||
To compile a single file <tt>foo.f</tt>, use
|
||||
To compile a single file <TT>foo.f</TT>, use
|
||||
<PRE>
|
||||
mpifort -c foo.f
|
||||
</PRE>
|
||||
@@ -88,19 +91,19 @@ Combining compilation and linking in a single command
|
||||
is a convenient way to build simple programs.
|
||||
<P>
|
||||
<H2>Selecting a Profiling Library</H2>
|
||||
The <tt>\-profile=name</tt> argument allows you to specify an MPI profiling
|
||||
library to be used. <tt>name</tt> can have two forms:
|
||||
The <TT>\-profile=name</TT> argument allows you to specify an MPI profiling
|
||||
library to be used. <TT>name</TT> can have two forms:
|
||||
<P>
|
||||
<br>A library in the same directory as the MPI library
|
||||
<br>The name of a profile configuration file
|
||||
<br>
|
||||
<BR>A library in the same directory as the MPI library
|
||||
<BR>The name of a profile configuration file
|
||||
<BR>
|
||||
<P>
|
||||
If <tt>name</tt> is a library, then this library is included before the MPI
|
||||
If <TT>name</TT> is a library, then this library is included before the MPI
|
||||
library. This allows the simple use of libraries that make use of the
|
||||
MPI profiling interface and that are installed in the same directory as
|
||||
the MPI library.
|
||||
<P>
|
||||
If <tt>name.conf</tt> is the name of a file in the sysconfdir directory, then this
|
||||
If <TT>name.conf</TT> is the name of a file in the sysconfdir directory, then this
|
||||
is read and may define the following variables:
|
||||
<DL>
|
||||
<DT><B>PROFILE_PRELIB </B><DD>Libraries (and paths) to include before the MPI library
|
||||
@@ -108,9 +111,9 @@ is read and may define the following variables:
|
||||
<DT><B>PROFILE_POSTLIB </B><DD>Libraries to include after the MPI library
|
||||
|
||||
<DT><B>PROFILE_INCPATHS </B><DD>C preprocessor arguments for any include files
|
||||
For example, to add <tt>/usr/local/myprof/include</tt> to the include path and
|
||||
the library <tt>libmyprof.a</tt> in <tt>/usr/local/myprof/lib</tt> to the link step,
|
||||
you could create the file <tt>myprof.conf</tt> with the lines
|
||||
For example, to add <TT>/usr/local/myprof/include</TT> to the include path and
|
||||
the library <TT>libmyprof.a</TT> in <TT>/usr/local/myprof/lib</TT> to the link step,
|
||||
you could create the file <TT>myprof.conf</TT> with the lines
|
||||
</DL>
|
||||
<P>
|
||||
<PRE>
|
||||
@@ -120,10 +123,10 @@ you could create the file <tt>myprof.conf</tt> with the lines
|
||||
|
||||
and place it in the sysconfdir directory (this directory is set at
|
||||
configure time when MPICH is built). Then using the command-line
|
||||
argument <tt>\-profile=myprof</tt> will cause these
|
||||
argument <TT>\-profile=myprof</TT> will cause these
|
||||
definitions to be added to the relevant compile commands.
|
||||
<P>
|
||||
<H0>See Also</H0>
|
||||
<H2>See Also</H2>
|
||||
mpicc, mpicxx, mpifort, mpiexec
|
||||
<br>
|
||||
<BR>
|
||||
</BODY></HTML>
|
||||
|
||||
@@ -10,9 +10,9 @@ Meaning of MPI's defined constants
|
||||
<H2>Data types</H2>
|
||||
Note that the Fortran types should only be used in Fortran programs,
|
||||
and the C types should only be used in C programs. For example,
|
||||
it is in error to use <tt>MPI_INT</tt> for a Fortran INTEGER.
|
||||
Datatypes are of type <tt>MPI_Datatype</tt> in C, type <tt>INTEGER</tt> in Fortran,
|
||||
and <tt>Type(MPI_Datatype)</tt> in Fortran08
|
||||
it is in error to use <TT>MPI_INT</TT> for a Fortran INTEGER.
|
||||
Datatypes are of type <TT>MPI_Datatype</TT> in C, type <TT>INTEGER</TT> in Fortran,
|
||||
and <TT>Type(MPI_Datatype)</TT> in Fortran08
|
||||
<P>
|
||||
<H2>C datatypes</H2>
|
||||
MPI_CHAR - char
|
||||
@@ -38,8 +38,8 @@ MPI_CHAR - char
|
||||
</DL>
|
||||
<DL><DT><B>MPI_LONG_LONG_INT </B> <DD> long long
|
||||
</DL>
|
||||
<DL><DT><B>MPI_LONG_LONG </B> <DD> synonyn for <tt>MPI_LONG_LONG_INT
|
||||
</tt>
|
||||
<DL><DT><B>MPI_LONG_LONG </B> <DD> synonyn for <TT>MPI_LONG_LONG_INT
|
||||
</TT>
|
||||
</DL>
|
||||
<DL><DT><B>MPI_UNSIGNED_LONG_LONG </B> <DD> unsigned long long
|
||||
</DL>
|
||||
@@ -78,103 +78,103 @@ MPI_CHAR - char
|
||||
</DL>
|
||||
<P>
|
||||
<P>
|
||||
The following are datatypes for the MPI functions <tt>MPI_MAXLOC</tt> and
|
||||
<tt>MPI_MINLOC</tt>.
|
||||
MPI_FLOAT_INT - <tt>struct { float, int }
|
||||
</tt>
|
||||
<DL><DT><B>MPI_LONG_INT </B> <DD> <tt>struct { long, int }
|
||||
</tt>
|
||||
The following are datatypes for the MPI functions <TT>MPI_MAXLOC</TT> and
|
||||
<TT>MPI_MINLOC</TT>.
|
||||
MPI_FLOAT_INT - <TT>struct { float, int }
|
||||
</TT>
|
||||
<DL><DT><B>MPI_LONG_INT </B> <DD> <TT>struct { long, int }
|
||||
</TT>
|
||||
</DL>
|
||||
<DL><DT><B>MPI_DOUBLE_INT </B> <DD> <tt>struct { double, int }
|
||||
</tt>
|
||||
<DL><DT><B>MPI_DOUBLE_INT </B> <DD> <TT>struct { double, int }
|
||||
</TT>
|
||||
</DL>
|
||||
<DL><DT><B>MPI_SHORT_INT </B> <DD> <tt>struct { short, int }
|
||||
</tt>
|
||||
<DL><DT><B>MPI_SHORT_INT </B> <DD> <TT>struct { short, int }
|
||||
</TT>
|
||||
</DL>
|
||||
<DL><DT><B>MPI_2INT </B> <DD> <tt>struct { int, int }
|
||||
</tt>
|
||||
<DL><DT><B>MPI_2INT </B> <DD> <TT>struct { int, int }
|
||||
</TT>
|
||||
</DL>
|
||||
<DL><DT><B>MPI_LONG_DOUBLE_INT </B> <DD> <tt>struct { long double, int }</tt>; this
|
||||
is an <em>optional</em> type, and may be set to <tt>MPI_DATATYPE_NULL
|
||||
</tt>
|
||||
<DL><DT><B>MPI_LONG_DOUBLE_INT </B> <DD> <TT>struct { long double, int }</TT>; this
|
||||
is an <EM>optional</EM> type, and may be set to <TT>MPI_DATATYPE_NULL
|
||||
</TT>
|
||||
</DL>
|
||||
</DL>
|
||||
<P>
|
||||
<P>
|
||||
Special datatypes for C and Fortran
|
||||
MPI_PACKED - For <tt>MPI_Pack</tt> and <tt>MPI_Unpack
|
||||
</tt>
|
||||
<DL><DT><B>MPI_UB </B> <DD> For <tt>MPI_Type_struct</tt>; an upper-bound indicator. Removed in MPI 3
|
||||
MPI_PACKED - For <TT>MPI_Pack</TT> and <TT>MPI_Unpack
|
||||
</TT>
|
||||
<DL><DT><B>MPI_UB </B> <DD> For <TT>MPI_Type_struct</TT>; an upper-bound indicator. Removed in MPI 3
|
||||
</DL>
|
||||
<DL><DT><B>MPI_LB </B> <DD> For <tt>MPI_Type_struct</tt>; a lower-bound indicator. Removed in MPI 3
|
||||
<DL><DT><B>MPI_LB </B> <DD> For <TT>MPI_Type_struct</TT>; a lower-bound indicator. Removed in MPI 3
|
||||
</DL>
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Fortran datatypes</H2>
|
||||
MPI_REAL - <tt>REAL
|
||||
</tt>
|
||||
<DL><DT><B>MPI_INTEGER </B> <DD> <tt>INTEGER
|
||||
</tt>
|
||||
MPI_REAL - <TT>REAL
|
||||
</TT>
|
||||
<DL><DT><B>MPI_INTEGER </B> <DD> <TT>INTEGER
|
||||
</TT>
|
||||
</DL>
|
||||
<DL><DT><B>MPI_LOGICAL </B> <DD> <tt>LOGICAL
|
||||
</tt>
|
||||
<DL><DT><B>MPI_LOGICAL </B> <DD> <TT>LOGICAL
|
||||
</TT>
|
||||
</DL>
|
||||
<DL><DT><B>MPI_DOUBLE_PRECISION </B> <DD> <tt>DOUBLE PRECISION
|
||||
</tt>
|
||||
<DL><DT><B>MPI_DOUBLE_PRECISION </B> <DD> <TT>DOUBLE PRECISION
|
||||
</TT>
|
||||
</DL>
|
||||
<DL><DT><B>MPI_COMPLEX </B> <DD> <tt>COMPLEX
|
||||
</tt>
|
||||
<DL><DT><B>MPI_COMPLEX </B> <DD> <TT>COMPLEX
|
||||
</TT>
|
||||
</DL>
|
||||
<DL><DT><B>MPI_DOUBLE_COMPLEX </B> <DD> <tt>complex*16</tt> (or <tt>complex*32</tt>) where supported.
|
||||
<DL><DT><B>MPI_DOUBLE_COMPLEX </B> <DD> <TT>complex*16</TT> (or <TT>complex*32</TT>) where supported.
|
||||
</DL>
|
||||
</DL>
|
||||
<P>
|
||||
The following datatypes are optional
|
||||
MPI_INTEGER1 - <tt>integer*1</tt> if supported
|
||||
<DL><DT><B>MPI_INTEGER2 </B> <DD> <tt>integer*2</tt> if supported
|
||||
MPI_INTEGER1 - <TT>integer*1</TT> if supported
|
||||
<DL><DT><B>MPI_INTEGER2 </B> <DD> <TT>integer*2</TT> if supported
|
||||
</DL>
|
||||
<DL><DT><B>MPI_INTEGER4 </B> <DD> <tt>integer*4</tt> if supported
|
||||
<DL><DT><B>MPI_INTEGER4 </B> <DD> <TT>integer*4</TT> if supported
|
||||
</DL>
|
||||
<DL><DT><B>MPI_INTEGER8 </B> <DD> <tt>integer*8</tt> if supported
|
||||
<DL><DT><B>MPI_INTEGER8 </B> <DD> <TT>integer*8</TT> if supported
|
||||
</DL>
|
||||
<DL><DT><B>MPI_INTEGER16 </B> <DD> <tt>integer*16</tt> if supported
|
||||
<DL><DT><B>MPI_INTEGER16 </B> <DD> <TT>integer*16</TT> if supported
|
||||
</DL>
|
||||
<DL><DT><B>MPI_REAL4 </B> <DD> <tt>real*4</tt> if supported
|
||||
<DL><DT><B>MPI_REAL4 </B> <DD> <TT>real*4</TT> if supported
|
||||
</DL>
|
||||
<DL><DT><B>MPI_REAL8 </B> <DD> <tt>real*8</tt> if supported
|
||||
<DL><DT><B>MPI_REAL8 </B> <DD> <TT>real*8</TT> if supported
|
||||
</DL>
|
||||
</DL>
|
||||
<DL><DT><B>MPI_REAL16 </B> <DD> <tt>real*16</tt> if supported
|
||||
<DL><DT><B>MPI_REAL16 </B> <DD> <TT>real*16</TT> if supported
|
||||
</DL>
|
||||
<DL><DT><B>MPI_COMPLEX8 </B> <DD> <tt>complex*8</tt> if supported
|
||||
<DL><DT><B>MPI_COMPLEX8 </B> <DD> <TT>complex*8</TT> if supported
|
||||
</DL>
|
||||
<DL><DT><B>MPI_COMPLEX16 </B> <DD> <tt>complex*16</tt> if supported
|
||||
<DL><DT><B>MPI_COMPLEX16 </B> <DD> <TT>complex*16</TT> if supported
|
||||
</DL>
|
||||
<DL><DT><B>MPI_COMPLEX32 </B> <DD> <tt>complex*32</tt> if supported
|
||||
<DL><DT><B>MPI_COMPLEX32 </B> <DD> <TT>complex*32</TT> if supported
|
||||
</DL>
|
||||
</DL>
|
||||
<P>
|
||||
The following are datatypes for the MPI functions <tt>MPI_MAXLOC</tt> and
|
||||
<tt>MPI_MINLOC</tt>. In Fortran, these datatype always consist of
|
||||
The following are datatypes for the MPI functions <TT>MPI_MAXLOC</TT> and
|
||||
<TT>MPI_MINLOC</TT>. In Fortran, these datatype always consist of
|
||||
two elements of the same Fortran type.
|
||||
MPI_2INTEGER - <tt>INTEGER,INTEGER
|
||||
</tt>
|
||||
<DL><DT><B>MPI_2REAL </B> <DD> <tt>REAL, REAL
|
||||
</tt>
|
||||
MPI_2INTEGER - <TT>INTEGER,INTEGER
|
||||
</TT>
|
||||
<DL><DT><B>MPI_2REAL </B> <DD> <TT>REAL, REAL
|
||||
</TT>
|
||||
</DL>
|
||||
<DL><DT><B>MPI_2DOUBLE_PRECISION </B> <DD> <tt>DOUBLE PRECISION, DOUBLE PRECISION
|
||||
</tt>
|
||||
<DL><DT><B>MPI_2DOUBLE_PRECISION </B> <DD> <TT>DOUBLE PRECISION, DOUBLE PRECISION
|
||||
</TT>
|
||||
</DL>
|
||||
</DL>
|
||||
<P>
|
||||
MPI Datatypes for MPI Types
|
||||
MPI_AINT - Datatype for an <tt>MPI_Aint
|
||||
</tt>
|
||||
<DL><DT><B>MPI_OFFSET </B> <DD> Datatype for an <tt>MPI_Offset
|
||||
</tt>
|
||||
MPI_AINT - Datatype for an <TT>MPI_Aint
|
||||
</TT>
|
||||
<DL><DT><B>MPI_OFFSET </B> <DD> Datatype for an <TT>MPI_Offset
|
||||
</TT>
|
||||
</DL>
|
||||
<DL><DT><B>MPI_COUNT </B> <DD> Datatype for an <tt>MPI_Count
|
||||
</tt>
|
||||
<DL><DT><B>MPI_COUNT </B> <DD> Datatype for an <TT>MPI_Count
|
||||
</TT>
|
||||
</DL>
|
||||
</DL>
|
||||
<P>
|
||||
@@ -221,19 +221,19 @@ MPI_COMBINER_NAMED - a named predefined datatype
|
||||
<H2>MPI Datatype Type Classes</H2>
|
||||
MPI Type classes used with routines to return Fortran types with defined
|
||||
precision and range
|
||||
MPI_TYPECLASS_REAL - <tt>REAL
|
||||
</tt>
|
||||
<DL><DT><B>MPI_TYPECLASS_INTEGER </B> <DD> <tt>INTEGER
|
||||
</tt>
|
||||
MPI_TYPECLASS_REAL - <TT>REAL
|
||||
</TT>
|
||||
<DL><DT><B>MPI_TYPECLASS_INTEGER </B> <DD> <TT>INTEGER
|
||||
</TT>
|
||||
</DL>
|
||||
<DL><DT><B>MPI_TYPECLASS_COMPLEX </B> <DD> <tt>COMPLEX
|
||||
</tt>
|
||||
<DL><DT><B>MPI_TYPECLASS_COMPLEX </B> <DD> <TT>COMPLEX
|
||||
</TT>
|
||||
</DL>
|
||||
</DL>
|
||||
<P>
|
||||
<H2>MPI Darray and Subarray Values</H2>
|
||||
These values are used to create a datatype with the <tt>DARRAY</tt> and <tt>SUBARRAY
|
||||
</tt>constructors.
|
||||
These values are used to create a datatype with the <TT>DARRAY</TT> and <TT>SUBARRAY
|
||||
</TT>constructors.
|
||||
MPI_ORDER_C - Row-major order (as used by C)
|
||||
<DL><DT><B>MPI_ORDER_FORTRAN </B> <DD> Column-major order (as used by Fortran)
|
||||
</DL>
|
||||
@@ -248,8 +248,8 @@ MPI_ORDER_C - Row-major order (as used by C)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Communicators</H2>
|
||||
Communicators are of type <tt>MPI_Comm</tt> in C, <tt>INTEGER</tt> in Fortran, and
|
||||
<tt>Type(MPI_Comm)</tt> in Fortran08
|
||||
Communicators are of type <TT>MPI_Comm</TT> in C, <TT>INTEGER</TT> in Fortran, and
|
||||
<TT>Type(MPI_Comm)</TT> in Fortran08
|
||||
MPI_COMM_WORLD - Contains all of the processes
|
||||
<DL><DT><B>MPI_COMM_SELF </B> <DD> Contains only the calling process
|
||||
</DL>
|
||||
@@ -260,14 +260,14 @@ MPI_COMM_TYPE_SHARED - All processes that can share memory are grouped into
|
||||
the same communicator.
|
||||
<P>
|
||||
<H2>Groups</H2>
|
||||
Groups are of type <tt>MPI_Group</tt> in C, <tt>INTEGER</tt> in Fortran,
|
||||
and <tt>Type(MPI_Group)</tt> in Fortran08
|
||||
Groups are of type <TT>MPI_Group</TT> in C, <TT>INTEGER</TT> in Fortran,
|
||||
and <TT>Type(MPI_Group)</TT> in Fortran08
|
||||
<P>
|
||||
MPI_GROUP_EMPTY - A group containing no members.
|
||||
<P>
|
||||
<H2>Results of the compare operations on groups and communicators</H2>
|
||||
MPI_IDENT - Identical
|
||||
<DL><DT><B>MPI_CONGRUENT </B> <DD> (only for <tt>MPI_COMM_COMPARE</tt>) The groups are identical
|
||||
<DL><DT><B>MPI_CONGRUENT </B> <DD> (only for <TT>MPI_COMM_COMPARE</TT>) The groups are identical
|
||||
</DL>
|
||||
<DL><DT><B>MPI_SIMILAR </B> <DD> Same members, but in a different order
|
||||
</DL>
|
||||
@@ -277,9 +277,9 @@ MPI_IDENT - Identical
|
||||
<P>
|
||||
<P>
|
||||
<H2>Collective operations</H2>
|
||||
The collective combination operations (e.g., <tt>MPI_REDUCE</tt>, <tt>MPI_ALLREDUCE</tt>,
|
||||
<tt>MPI_REDUCE_SCATTER</tt>, and <tt>MPI_SCAN</tt>) take a combination operation.
|
||||
This operation is of type <tt>MPI_Op</tt> in C and of type <tt>INTEGER</tt> in Fortran.
|
||||
The collective combination operations (e.g., <TT>MPI_REDUCE</TT>, <TT>MPI_ALLREDUCE</TT>,
|
||||
<TT>MPI_REDUCE_SCATTER</TT>, and <TT>MPI_SCAN</TT>) take a combination operation.
|
||||
This operation is of type <TT>MPI_Op</TT> in C and of type <TT>INTEGER</TT> in Fortran.
|
||||
The predefined operations are
|
||||
<P>
|
||||
MPI_MAX - return the maximum
|
||||
@@ -315,24 +315,24 @@ the first is found)
|
||||
<P>
|
||||
<H2>Notes on collective operations</H2>
|
||||
<P>
|
||||
The reduction functions (<tt>MPI_Op</tt>) do not return an error value. As a result,
|
||||
if the functions detect an error, all they can do is either call <tt>MPI_Abort
|
||||
</tt>or silently skip the problem. Thus, if you change the error handler from
|
||||
<tt>MPI_ERRORS_ARE_FATAL</tt> to something else, for example, <tt>MPI_ERRORS_RETURN</tt>,
|
||||
The reduction functions (<TT>MPI_Op</TT>) do not return an error value. As a result,
|
||||
if the functions detect an error, all they can do is either call <TT>MPI_Abort
|
||||
</TT>or silently skip the problem. Thus, if you change the error handler from
|
||||
<TT>MPI_ERRORS_ARE_FATAL</TT> to something else, for example, <TT>MPI_ERRORS_RETURN</TT>,
|
||||
then no error may be indicated.
|
||||
<P>
|
||||
The reason for this is the performance problems in ensuring that
|
||||
all collective routines return the same error value.
|
||||
<P>
|
||||
Note that not all datatypes are valid for these functions. For example,
|
||||
<tt>MPI_COMPLEX</tt> is not valid for <tt>MPI_MAX</tt> and <tt>MPI_MIN</tt>. In addition, the MPI
|
||||
1.1 standard did not include the C types <tt>MPI_CHAR</tt> and <tt>MPI_UNSIGNED_CHAR
|
||||
</tt>among the lists of arithmetic types for operations like <tt>MPI_SUM</tt>. However,
|
||||
since the C type <tt>char</tt> is an integer type (like <tt>short</tt>), it should have been
|
||||
included. The MPI Forum will probably include <tt>char</tt> and <tt>unsigned char
|
||||
</tt>as a clarification to MPI 1.1; until then, users are advised that MPI
|
||||
implementations may not accept <tt>MPI_CHAR</tt> and <tt>MPI_UNSIGNED_CHAR</tt> as valid
|
||||
datatypes for <tt>MPI_SUM</tt>, <tt>MPI_PROD</tt>, etc. MPICH does allow these datatypes.
|
||||
<TT>MPI_COMPLEX</TT> is not valid for <TT>MPI_MAX</TT> and <TT>MPI_MIN</TT>. In addition, the MPI
|
||||
1.1 standard did not include the C types <TT>MPI_CHAR</TT> and <TT>MPI_UNSIGNED_CHAR
|
||||
</TT>among the lists of arithmetic types for operations like <TT>MPI_SUM</TT>. However,
|
||||
since the C type <TT>char</TT> is an integer type (like <TT>short</TT>), it should have been
|
||||
included. The MPI Forum will probably include <TT>char</TT> and <TT>unsigned char
|
||||
</TT>as a clarification to MPI 1.1; until then, users are advised that MPI
|
||||
implementations may not accept <TT>MPI_CHAR</TT> and <TT>MPI_UNSIGNED_CHAR</TT> as valid
|
||||
datatypes for <TT>MPI_SUM</TT>, <TT>MPI_PROD</TT>, etc. MPICH does allow these datatypes.
|
||||
<P>
|
||||
<H2>Permanent key values</H2>
|
||||
These are the same in C and Fortran
|
||||
@@ -342,7 +342,7 @@ MPI_TAG_UB - Largest tag value
|
||||
</DL>
|
||||
<DL><DT><B>MPI_IO </B> <DD> Rank of process that can do I/O
|
||||
</DL>
|
||||
<DL><DT><B>MPI_WTIME_IS_GLOBAL </B> <DD> Has value 1 if <tt>MPI_WTIME</tt> is globally synchronized.
|
||||
<DL><DT><B>MPI_WTIME_IS_GLOBAL </B> <DD> Has value 1 if <TT>MPI_WTIME</TT> is globally synchronized.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_UNIVERSE_SIZE </B> <DD> Number of available processes. See the standard for
|
||||
a description of limitations on this value
|
||||
@@ -350,7 +350,7 @@ a description of limitations on this value
|
||||
<DL><DT><B>MPI_LASTUSEDCODE </B> <DD> Last used MPI error code (check - code or class?)
|
||||
</DL>
|
||||
<DL><DT><B>MPI_APPNUM </B> <DD> Application number, starting from 0. See the standard for
|
||||
<tt>MPI_COMM_SPAWN_MULTIPLE</tt> and <tt>mpiexec</tt> for details
|
||||
<TT>MPI_COMM_SPAWN_MULTIPLE</TT> and <TT>mpiexec</TT> for details
|
||||
</DL>
|
||||
</DL>
|
||||
<P>
|
||||
@@ -390,14 +390,14 @@ MPI_COMM_NULL - Null communicator
|
||||
<P>
|
||||
<H2>Predefined Constants</H2>
|
||||
MPI_MAX_PROCESSOR_NAME - Maximum length of name returned by
|
||||
<tt>MPI_GET_PROCESSOR_NAME
|
||||
</tt>
|
||||
<TT>MPI_GET_PROCESSOR_NAME
|
||||
</TT>
|
||||
<DL><DT><B>MPI_MAX_ERROR_STRING </B> <DD> Maximum length of string return by
|
||||
<tt>MPI_ERROR_STRING
|
||||
</tt>
|
||||
<TT>MPI_ERROR_STRING
|
||||
</TT>
|
||||
</DL>
|
||||
<DL><DT><B>MPI_MAX_LIBRARY_VERSION_STRING </B> <DD> Maximum length of string returned by
|
||||
<tt>MPI_GET_LIBRARY_VERSION_STRING</tt>???
|
||||
<TT>MPI_GET_LIBRARY_VERSION_STRING</TT>???
|
||||
</DL>
|
||||
<DL><DT><B>MPI_MAX_PORT_NAME </B> <DD> Maximum length of a port
|
||||
</DL>
|
||||
@@ -415,8 +415,8 @@ undefined or unknown integer value
|
||||
<DL><DT><B>MPI_KEYVAL_INVALID </B> <DD> Special keyval that may be used to detect
|
||||
uninitialized keyvals.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_BSEND_OVERHEAD </B> <DD> Add this to the size of a <tt>MPI_BSEND
|
||||
</tt>buffer for each outstanding message
|
||||
<DL><DT><B>MPI_BSEND_OVERHEAD </B> <DD> Add this to the size of a <TT>MPI_BSEND
|
||||
</TT>buffer for each outstanding message
|
||||
</DL>
|
||||
<DL><DT><B>MPI_PROC_NULL </B> <DD> This rank may be used to send or receive from no-one.
|
||||
</DL>
|
||||
@@ -474,17 +474,17 @@ the end of the file
|
||||
<P>
|
||||
<H2>File Displacement</H2>
|
||||
MPI_DISPLACEMENT_CURRENT - Use with files opened with mode
|
||||
<tt>MPI_MODE_SEQUENTIAL</tt> in calls to <tt>MPI_FILE_SET_VIEW
|
||||
</tt>
|
||||
<TT>MPI_MODE_SEQUENTIAL</TT> in calls to <TT>MPI_FILE_SET_VIEW
|
||||
</TT>
|
||||
<P>
|
||||
<H2>File Positioning</H2>
|
||||
MPI_SEEK_SET - Set the pointer to <tt>offset
|
||||
</tt>
|
||||
<DL><DT><B>MPI_SEEK_CUR </B> <DD> Set the pointer to the current position plus <tt>offset
|
||||
</tt>
|
||||
MPI_SEEK_SET - Set the pointer to <TT>offset
|
||||
</TT>
|
||||
<DL><DT><B>MPI_SEEK_CUR </B> <DD> Set the pointer to the current position plus <TT>offset
|
||||
</TT>
|
||||
</DL>
|
||||
<DL><DT><B>MPI_SEEK_END </B> <DD> Set the pointer to the end of the file plus <tt>offset
|
||||
</tt>
|
||||
<DL><DT><B>MPI_SEEK_END </B> <DD> Set the pointer to the end of the file plus <TT>offset
|
||||
</TT>
|
||||
</DL>
|
||||
</DL>
|
||||
<P>
|
||||
@@ -548,19 +548,19 @@ calls
|
||||
MPI_INFO_ENV - Contains the execution environment
|
||||
<P>
|
||||
<H2>MPI Status</H2>
|
||||
The <tt>MPI_Status</tt> datatype is a structure in C. The three elements for use
|
||||
The <TT>MPI_Status</TT> datatype is a structure in C. The three elements for use
|
||||
by programmers are
|
||||
MPI_SOURCE - Who sent the message
|
||||
<DL><DT><B>MPI_TAG </B> <DD> What tag the message was sent with
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERROR </B> <DD> Any error return (only when the error returned by the routine
|
||||
has error class <tt>MPI_ERR_IN_STATUS</tt>)
|
||||
has error class <TT>MPI_ERR_IN_STATUS</TT>)
|
||||
</DL>
|
||||
</DL>
|
||||
<P>
|
||||
MPI_STATUS_IGNORE - Ignore a single <tt>MPI_Status</tt> argument
|
||||
<DL><DT><B>MPI_STATUSES_IGNORE </B> <DD> Ignore an array of <tt>MPI_Status
|
||||
</tt>
|
||||
MPI_STATUS_IGNORE - Ignore a single <TT>MPI_Status</TT> argument
|
||||
<DL><DT><B>MPI_STATUSES_IGNORE </B> <DD> Ignore an array of <TT>MPI_Status
|
||||
</TT>
|
||||
</DL>
|
||||
</DL>
|
||||
<P>
|
||||
@@ -671,14 +671,14 @@ MPI_Aint - C type that holds any valid address.
|
||||
<DL><DT><B>MPI_Offset </B> <DD> C type that holds any valid file offset.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_Handler_function </B> <DD> C function for handling errors (see
|
||||
<tt>MPI_Errhandler_create</tt>) .
|
||||
<TT>MPI_Errhandler_create</TT>) .
|
||||
</DL>
|
||||
<DL><DT><B>MPI_User_function </B> <DD> C function to combine values (see collective operations
|
||||
and <tt>MPI_Op_create</tt>)
|
||||
and <TT>MPI_Op_create</TT>)
|
||||
</DL>
|
||||
<DL><DT><B>MPI_Copy_function </B> <DD> Function to copy attributes (see <tt>MPI_Keyval_create</tt>)
|
||||
<DL><DT><B>MPI_Copy_function </B> <DD> Function to copy attributes (see <TT>MPI_Keyval_create</TT>)
|
||||
</DL>
|
||||
<DL><DT><B>MPI_Delete_function </B> <DD> Function to delete attributes (see <tt>MPI_Keyval_create</tt>)
|
||||
<DL><DT><B>MPI_Delete_function </B> <DD> Function to delete attributes (see <TT>MPI_Keyval_create</TT>)
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERRORS_ARE_FATAL </B> <DD> Error handler that forces exit on error
|
||||
</DL>
|
||||
@@ -758,8 +758,8 @@ MPI_SUCCESS - Successful return code
|
||||
<DL><DT><B>MPI_ERR_ACCESS </B> <DD> Permission denied
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_AMODE </B> <DD> Error related to the amode passed to
|
||||
<tt>MPI_FILE_OPEN
|
||||
</tt>
|
||||
<TT>MPI_FILE_OPEN
|
||||
</TT>
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_BAD_FILE </B> <DD> Invalid file name (e.g., path name too long)
|
||||
</DL>
|
||||
@@ -768,8 +768,8 @@ conversion function
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_DUP_DATAREP </B> <DD> Conversion functions could not be registered
|
||||
because a data representation identifier that was already defined was passed
|
||||
to <tt>MPI_REGISTER_DATAREP
|
||||
</tt>
|
||||
to <TT>MPI_REGISTER_DATAREP
|
||||
</TT>
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_FILE_EXISTS </B> <DD> File exists
|
||||
</DL>
|
||||
@@ -787,8 +787,8 @@ the file is currently open by some process
|
||||
<DL><DT><B>MPI_ERR_READ_ONLY </B> <DD> Read-only file or file system
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_UNSUPPORTED_DATAREP </B> <DD> Unsupported datarep passed to
|
||||
<tt>MPI_FILE_SET_VIEW
|
||||
</tt>
|
||||
<TT>MPI_FILE_SET_VIEW
|
||||
</TT>
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_INFO </B> <DD> Invalid info argument
|
||||
</DL>
|
||||
|
||||
18
linx64/mpi/mpich/share/doc/mpich/www3/MPIR_Type_commit.html
Normal file
18
linx64/mpi/mpich/share/doc/mpich/www3/MPIR_Type_commit.html
Normal file
@@ -0,0 +1,18 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPIR_Type_commit</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPIR_Type_commit"><H1>MPIR_Type_commit</H1></A>
|
||||
nput Parameters: . datatype_p - pointer to MPI datatype
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
int MPIR_Type_commit(MPI_Datatype * datatype_p)
|
||||
</PRE>
|
||||
<H2>Output Parameters</H2>
|
||||
<P>
|
||||
<H2>Return Value</H2>
|
||||
0 on success, -1 on failure.
|
||||
</BODY></HTML>
|
||||
@@ -0,0 +1,27 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPIR_Type_contiguous</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPIR_Type_contiguous"><H1>MPIR_Type_contiguous</H1></A>
|
||||
create a contiguous datatype
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
int MPIR_Type_contiguous(int count, MPI_Datatype oldtype, MPI_Datatype * newtype)
|
||||
</PRE>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>count </B><DD>number of elements in the contiguous block
|
||||
|
||||
<DT><B>oldtype </B><DD>type (using handle) of datatype on which vector is based
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL><DT><B>newtype </B> <DD> handle of new contiguous datatype
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Return Value</H2>
|
||||
MPI_SUCCESS on success, MPI error code on failure.
|
||||
</BODY></HTML>
|
||||
29
linx64/mpi/mpich/share/doc/mpich/www3/MPIR_Type_dup.html
Normal file
29
linx64/mpi/mpich/share/doc/mpich/www3/MPIR_Type_dup.html
Normal file
@@ -0,0 +1,29 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPIR_Type_dup</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPIR_Type_dup"><H1>MPIR_Type_dup</H1></A>
|
||||
create a copy of a datatype
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
#undef FUNCNAME
|
||||
#define FUNCNAME MPIR_Type_dup
|
||||
#undef FCNAME
|
||||
#define FCNAME MPL_QUOTE(FUNCNAME)
|
||||
int MPIR_Type_dup(MPI_Datatype oldtype, MPI_Datatype * newtype)
|
||||
</PRE>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL><DT><B>oldtype </B> <DD> handle of original datatype
|
||||
</DL>
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL><DT><B>newtype </B> <DD> handle of newly created copy of datatype
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Return Value</H2>
|
||||
0 on success, MPI error code on failure.
|
||||
</BODY></HTML>
|
||||
@@ -0,0 +1,39 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPIR_Type_get_contents</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPIR_Type_get_contents"><H1>MPIR_Type_get_contents</H1></A>
|
||||
get content information from datatype
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
int MPIR_Type_get_contents(MPI_Datatype datatype,
|
||||
int max_integers,
|
||||
int max_addresses,
|
||||
int max_datatypes,
|
||||
int array_of_integers[],
|
||||
MPI_Aint array_of_addresses[], MPI_Datatype array_of_datatypes[])
|
||||
</PRE>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>datatype </B><DD>MPI datatype
|
||||
|
||||
<DT><B>max_integers </B><DD>size of array_of_integers
|
||||
|
||||
<DT><B>max_addresses </B><DD>size of array_of_addresses
|
||||
|
||||
<DT><B>max_datatypes </B><DD>size of array_of_datatypes
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>array_of_integers </B><DD>integers used in creating type
|
||||
|
||||
<DT><B>array_of_addresses </B><DD>MPI_Aints used in creating type
|
||||
|
||||
<DT><B>array_of_datatypes </B><DD>MPI_Datatypes used in creating type
|
||||
</DL>
|
||||
<P>
|
||||
</BODY></HTML>
|
||||
39
linx64/mpi/mpich/share/doc/mpich/www3/MPIR_Type_indexed.html
Normal file
39
linx64/mpi/mpich/share/doc/mpich/www3/MPIR_Type_indexed.html
Normal file
@@ -0,0 +1,39 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPIR_Type_indexed</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPIR_Type_indexed"><H1>MPIR_Type_indexed</H1></A>
|
||||
create an indexed datatype
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
int MPIR_Type_indexed(int count,
|
||||
const int *blocklength_array,
|
||||
const void *displacement_array,
|
||||
int dispinbytes, MPI_Datatype oldtype, MPI_Datatype * newtype)
|
||||
</PRE>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>count </B><DD>number of blocks in type
|
||||
|
||||
<DT><B>blocklength_array </B><DD>number of elements in each block
|
||||
|
||||
<DT><B>displacement_array </B><DD>offsets of blocks from start of type (see next
|
||||
parameter for units)
|
||||
|
||||
<DT><B>dispinbytes </B><DD>if nonzero, then displacements are in bytes (the
|
||||
displacement_array is an array of ints), otherwise they in terms of
|
||||
extent of oldtype (the displacement_array is an array of MPI_Aints)
|
||||
|
||||
<DT><B>oldtype </B><DD>type (using handle) of datatype on which new type is based
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL><DT><B>newtype </B> <DD> handle of new indexed datatype
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Return Value</H2>
|
||||
0 on success, -1 on failure.
|
||||
</BODY></HTML>
|
||||
38
linx64/mpi/mpich/share/doc/mpich/www3/MPIR_Type_struct.html
Normal file
38
linx64/mpi/mpich/share/doc/mpich/www3/MPIR_Type_struct.html
Normal file
@@ -0,0 +1,38 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPIR_Type_struct</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPIR_Type_struct"><H1>MPIR_Type_struct</H1></A>
|
||||
create a struct datatype
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
#undef FUNCNAME
|
||||
#define FUNCNAME MPIR_Type_struct
|
||||
#undef FCNAME
|
||||
#define FCNAME MPL_QUOTE(FUNCNAME)
|
||||
int MPIR_Type_struct(int count,
|
||||
const int *blocklength_array,
|
||||
const MPI_Aint * displacement_array,
|
||||
const MPI_Datatype * oldtype_array, MPI_Datatype * newtype)
|
||||
</PRE>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>count </B><DD>number of blocks in vector
|
||||
|
||||
<DT><B>blocklength_array </B><DD>number of elements in each block
|
||||
|
||||
<DT><B>displacement_array </B><DD>offsets of blocks from start of type in bytes
|
||||
|
||||
<DT><B>oldtype_array </B><DD>types (using handle) of datatypes on which vector is based
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL><DT><B>newtype </B> <DD> handle of new struct datatype
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Return Value</H2>
|
||||
MPI_SUCCESS on success, MPI errno on failure.
|
||||
</BODY></HTML>
|
||||
38
linx64/mpi/mpich/share/doc/mpich/www3/MPIR_Type_vector.html
Normal file
38
linx64/mpi/mpich/share/doc/mpich/www3/MPIR_Type_vector.html
Normal file
@@ -0,0 +1,38 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPIR_Type_vector</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPIR_Type_vector"><H1>MPIR_Type_vector</H1></A>
|
||||
create a vector datatype
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
int MPIR_Type_vector(int count,
|
||||
int blocklength,
|
||||
MPI_Aint stride,
|
||||
int strideinbytes, MPI_Datatype oldtype, MPI_Datatype * newtype)
|
||||
</PRE>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>count </B><DD>number of blocks in vector
|
||||
|
||||
<DT><B>blocklength </B><DD>number of elements in each block
|
||||
|
||||
<DT><B>stride </B><DD>distance from beginning of one block to the next (see next
|
||||
parameter for units)
|
||||
|
||||
<DT><B>strideinbytes </B><DD>if nonzero, then stride is in bytes, otherwise stride
|
||||
is in terms of extent of oldtype
|
||||
|
||||
<DT><B>oldtype </B><DD>type (using handle) of datatype on which vector is based
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL><DT><B>newtype </B> <DD> handle of new vector datatype
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Return Value</H2>
|
||||
0 on success, MPI error code on failure.
|
||||
</BODY></HTML>
|
||||
@@ -24,38 +24,38 @@ int MPIX_Comm_agree(MPI_Comm comm, int *flag)
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
this is due to the use of memory allocation routines such as <TT>malloc
|
||||
</TT>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
All MPI routines in Fortran (except for <TT>MPI_WTIME</TT> and <TT>MPI_WTICK</TT>) have
|
||||
an additional argument <TT>ierr</TT> at the end of the argument list. <TT>ierr
|
||||
</TT>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<TT>call</TT> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
All MPI objects (e.g., <TT>MPI_Datatype</TT>, <TT>MPI_Comm</TT>) are of type <TT>INTEGER
|
||||
</TT>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
All MPI routines (except <TT>MPI_Wtime</TT> and <TT>MPI_Wtick</TT>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
may be changed with <TT>MPI_Comm_set_errhandler</TT> (for communicators),
|
||||
<TT>MPI_File_set_errhandler</TT> (for files), and <TT>MPI_Win_set_errhandler</TT> (for
|
||||
RMA windows). The MPI-1 routine <TT>MPI_Errhandler_set</TT> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarentee that an MPI program can continue past
|
||||
<TT>MPI_ERRORS_RETURN</TT> may be used to cause error values to be returned.
|
||||
Note that MPI does <EM>not</EM> guarentee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL><DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_COMM </B> <DD> Invalid communicator. A common error is to use a null
|
||||
communicator in a call (not even allowed in <tt>MPI_Comm_rank</tt>).
|
||||
communicator in a call (not even allowed in <TT>MPI_Comm_rank</TT>).
|
||||
</DL>
|
||||
<P>
|
||||
</BODY></HTML>
|
||||
|
||||
@@ -9,53 +9,53 @@
|
||||
Acknowledge the current group of failed processes
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
int MPIX_Comm_failure_ack( MPI_Comm comm )
|
||||
int MPIX_Comm_failure_ack(MPI_Comm comm)
|
||||
</PRE>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL><DT><B>comm </B> <DD> Communicator (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Notes</H2>
|
||||
Because MPI specifies that null objects (e.g., <tt>MPI_COMM_NULL</tt>) are invalid
|
||||
as input to MPI routines unless otherwise specified, using <tt>MPI_COMM_NULL
|
||||
</tt>as input to this routine is an error.
|
||||
Because MPI specifies that null objects (e.g., <TT>MPI_COMM_NULL</TT>) are invalid
|
||||
as input to MPI routines unless otherwise specified, using <TT>MPI_COMM_NULL
|
||||
</TT>as input to this routine is an error.
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
<P>
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
this is due to the use of memory allocation routines such as <TT>malloc
|
||||
</TT>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
All MPI routines in Fortran (except for <TT>MPI_WTIME</TT> and <TT>MPI_WTICK</TT>) have
|
||||
an additional argument <TT>ierr</TT> at the end of the argument list. <TT>ierr
|
||||
</TT>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<TT>call</TT> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
All MPI objects (e.g., <TT>MPI_Datatype</TT>, <TT>MPI_Comm</TT>) are of type <TT>INTEGER
|
||||
</TT>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
All MPI routines (except <TT>MPI_Wtime</TT> and <TT>MPI_Wtick</TT>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
may be changed with <TT>MPI_Comm_set_errhandler</TT> (for communicators),
|
||||
<TT>MPI_File_set_errhandler</TT> (for files), and <TT>MPI_Win_set_errhandler</TT> (for
|
||||
RMA windows). The MPI-1 routine <TT>MPI_Errhandler_set</TT> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarentee that an MPI program can continue past
|
||||
<TT>MPI_ERRORS_RETURN</TT> may be used to cause error values to be returned.
|
||||
Note that MPI does <EM>not</EM> guarentee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL><DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_COMM </B> <DD> Invalid communicator. A common error is to use a null
|
||||
communicator in a call (not even allowed in <tt>MPI_Comm_rank</tt>).
|
||||
communicator in a call (not even allowed in <TT>MPI_Comm_rank</TT>).
|
||||
</DL>
|
||||
</BODY></HTML>
|
||||
|
||||
@@ -9,7 +9,7 @@
|
||||
Get the group of acknowledged failures.
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
int MPIX_Comm_failure_get_acked( MPI_Comm comm, MPI_Group *failedgrp )
|
||||
int MPIX_Comm_failure_get_acked(MPI_Comm comm, MPI_Group * failedgrp)
|
||||
</PRE>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL><DT><B>comm </B> <DD> Communicator (handle)
|
||||
@@ -20,46 +20,46 @@ int MPIX_Comm_failure_get_acked( MPI_Comm comm, MPI_Group *failedgrp )
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Notes</H2>
|
||||
Because MPI specifies that null objects (e.g., <tt>MPI_COMM_NULL</tt>) are invalid
|
||||
as input to MPI routines unless otherwise specified, using <tt>MPI_COMM_NULL
|
||||
</tt>as input to this routine is an error.
|
||||
Because MPI specifies that null objects (e.g., <TT>MPI_COMM_NULL</TT>) are invalid
|
||||
as input to MPI routines unless otherwise specified, using <TT>MPI_COMM_NULL
|
||||
</TT>as input to this routine is an error.
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
<P>
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
this is due to the use of memory allocation routines such as <TT>malloc
|
||||
</TT>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
All MPI routines in Fortran (except for <TT>MPI_WTIME</TT> and <TT>MPI_WTICK</TT>) have
|
||||
an additional argument <TT>ierr</TT> at the end of the argument list. <TT>ierr
|
||||
</TT>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<TT>call</TT> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
All MPI objects (e.g., <TT>MPI_Datatype</TT>, <TT>MPI_Comm</TT>) are of type <TT>INTEGER
|
||||
</TT>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
All MPI routines (except <TT>MPI_Wtime</TT> and <TT>MPI_Wtick</TT>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
may be changed with <TT>MPI_Comm_set_errhandler</TT> (for communicators),
|
||||
<TT>MPI_File_set_errhandler</TT> (for files), and <TT>MPI_Win_set_errhandler</TT> (for
|
||||
RMA windows). The MPI-1 routine <TT>MPI_Errhandler_set</TT> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarentee that an MPI program can continue past
|
||||
<TT>MPI_ERRORS_RETURN</TT> may be used to cause error values to be returned.
|
||||
Note that MPI does <EM>not</EM> guarentee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL><DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_COMM </B> <DD> Invalid communicator. A common error is to use a null
|
||||
communicator in a call (not even allowed in <tt>MPI_Comm_rank</tt>).
|
||||
communicator in a call (not even allowed in <TT>MPI_Comm_rank</TT>).
|
||||
</DL>
|
||||
</BODY></HTML>
|
||||
|
||||
@@ -16,32 +16,32 @@ int MPIX_Comm_revoke(MPI_Comm comm)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Notes</H2>
|
||||
Asynchronously notifies all MPI processes associated with the communicator <tt>comm</tt>.
|
||||
Asynchronously notifies all MPI processes associated with the communicator <TT>comm</TT>.
|
||||
This will be manifest by returning the MPIX_ERR_REVOKED during a subsequent MPI
|
||||
call.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
All MPI routines in Fortran (except for <TT>MPI_WTIME</TT> and <TT>MPI_WTICK</TT>) have
|
||||
an additional argument <TT>ierr</TT> at the end of the argument list. <TT>ierr
|
||||
</TT>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<TT>call</TT> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
All MPI objects (e.g., <TT>MPI_Datatype</TT>, <TT>MPI_Comm</TT>) are of type <TT>INTEGER
|
||||
</TT>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
All MPI routines (except <TT>MPI_Wtime</TT> and <TT>MPI_Wtick</TT>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
may be changed with <TT>MPI_Comm_set_errhandler</TT> (for communicators),
|
||||
<TT>MPI_File_set_errhandler</TT> (for files), and <TT>MPI_Win_set_errhandler</TT> (for
|
||||
RMA windows). The MPI-1 routine <TT>MPI_Errhandler_set</TT> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarentee that an MPI program can continue past
|
||||
<TT>MPI_ERRORS_RETURN</TT> may be used to cause error values to be returned.
|
||||
Note that MPI does <EM>not</EM> guarentee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
|
||||
@@ -9,7 +9,7 @@
|
||||
Creates a new communitor from an existing communicator while excluding failed processes
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
int MPIX_Comm_shrink(MPI_Comm comm, MPI_Comm *newcomm)
|
||||
int MPIX_Comm_shrink(MPI_Comm comm, MPI_Comm * newcomm)
|
||||
</PRE>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL><DT><B>comm </B> <DD> communicator (handle)
|
||||
@@ -24,38 +24,38 @@ int MPIX_Comm_shrink(MPI_Comm comm, MPI_Comm *newcomm)
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
this is due to the use of memory allocation routines such as <TT>malloc
|
||||
</TT>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
All MPI routines in Fortran (except for <TT>MPI_WTIME</TT> and <TT>MPI_WTICK</TT>) have
|
||||
an additional argument <TT>ierr</TT> at the end of the argument list. <TT>ierr
|
||||
</TT>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<TT>call</TT> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
All MPI objects (e.g., <TT>MPI_Datatype</TT>, <TT>MPI_Comm</TT>) are of type <TT>INTEGER
|
||||
</TT>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
All MPI routines (except <TT>MPI_Wtime</TT> and <TT>MPI_Wtick</TT>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
may be changed with <TT>MPI_Comm_set_errhandler</TT> (for communicators),
|
||||
<TT>MPI_File_set_errhandler</TT> (for files), and <TT>MPI_Win_set_errhandler</TT> (for
|
||||
RMA windows). The MPI-1 routine <TT>MPI_Errhandler_set</TT> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarentee that an MPI program can continue past
|
||||
<TT>MPI_ERRORS_RETURN</TT> may be used to cause error values to be returned.
|
||||
Note that MPI does <EM>not</EM> guarentee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL><DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_COMM </B> <DD> Invalid communicator. A common error is to use a null
|
||||
communicator in a call (not even allowed in <tt>MPI_Comm_rank</tt>).
|
||||
communicator in a call (not even allowed in <TT>MPI_Comm_rank</TT>).
|
||||
</DL>
|
||||
<P>
|
||||
</BODY></HTML>
|
||||
|
||||
@@ -19,8 +19,8 @@ int MPI_Abort(MPI_Comm comm, int errorcode)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Notes</H2>
|
||||
Terminates all MPI processes associated with the communicator <tt>comm</tt>; in
|
||||
most systems (all to date), terminates <em>all</em> processes.
|
||||
Terminates all MPI processes associated with the communicator <TT>comm</TT>; in
|
||||
most systems (all to date), terminates <EM>all</EM> processes.
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
<P>
|
||||
@@ -31,35 +31,35 @@ not be used from within a signal handler.
|
||||
The MPI standard defined a thread-safe interface but this does not
|
||||
mean that all routines may be called without any thread locks. For
|
||||
example, two threads must not attempt to change the contents of the
|
||||
same <tt>MPI_Info</tt> object concurrently. The user is responsible in this
|
||||
same <TT>MPI_Info</TT> object concurrently. The user is responsible in this
|
||||
case for using some mechanism, such as thread locks, to ensure that
|
||||
only one thread at a time makes use of this routine.
|
||||
Because the <tt>MPI_Abort</tt> routine is intended to ensure that an MPI
|
||||
Because the <TT>MPI_Abort</TT> routine is intended to ensure that an MPI
|
||||
process (and possibly an entire job), it cannot wait for a thread to
|
||||
release a lock or other mechanism for atomic access.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
All MPI routines in Fortran (except for <TT>MPI_WTIME</TT> and <TT>MPI_WTICK</TT>) have
|
||||
an additional argument <TT>ierr</TT> at the end of the argument list. <TT>ierr
|
||||
</TT>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<TT>call</TT> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
All MPI objects (e.g., <TT>MPI_Datatype</TT>, <TT>MPI_Comm</TT>) are of type <TT>INTEGER
|
||||
</TT>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
All MPI routines (except <TT>MPI_Wtime</TT> and <TT>MPI_Wtick</TT>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
may be changed with <TT>MPI_Comm_set_errhandler</TT> (for communicators),
|
||||
<TT>MPI_File_set_errhandler</TT> (for files), and <TT>MPI_Win_set_errhandler</TT> (for
|
||||
RMA windows). The MPI-1 routine <TT>MPI_Errhandler_set</TT> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarentee that an MPI program can continue past
|
||||
<TT>MPI_ERRORS_RETURN</TT> may be used to cause error values to be returned.
|
||||
Note that MPI does <EM>not</EM> guarentee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
|
||||
@@ -38,53 +38,53 @@ buffer (nonnegative integer)
|
||||
<P>
|
||||
<H2>Notes</H2>
|
||||
The basic components of both the origin and target datatype must be the same
|
||||
predefined datatype (e.g., all <tt>MPI_INT</tt> or all <tt>MPI_DOUBLE_PRECISION</tt>).
|
||||
predefined datatype (e.g., all <TT>MPI_INT</TT> or all <TT>MPI_DOUBLE_PRECISION</TT>).
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
All MPI routines in Fortran (except for <TT>MPI_WTIME</TT> and <TT>MPI_WTICK</TT>) have
|
||||
an additional argument <TT>ierr</TT> at the end of the argument list. <TT>ierr
|
||||
</TT>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<TT>call</TT> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
All MPI objects (e.g., <TT>MPI_Datatype</TT>, <TT>MPI_Comm</TT>) are of type <TT>INTEGER
|
||||
</TT>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
All MPI routines (except <TT>MPI_Wtime</TT> and <TT>MPI_Wtick</TT>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
may be changed with <TT>MPI_Comm_set_errhandler</TT> (for communicators),
|
||||
<TT>MPI_File_set_errhandler</TT> (for files), and <TT>MPI_Win_set_errhandler</TT> (for
|
||||
RMA windows). The MPI-1 routine <TT>MPI_Errhandler_set</TT> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarentee that an MPI program can continue past
|
||||
<TT>MPI_ERRORS_RETURN</TT> may be used to cause error values to be returned.
|
||||
Note that MPI does <EM>not</EM> guarentee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL><DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_ARG </B> <DD> Invalid argument. Some argument is invalid and is not
|
||||
identified by a specific error class (e.g., <tt>MPI_ERR_RANK</tt>).
|
||||
identified by a specific error class (e.g., <TT>MPI_ERR_RANK</TT>).
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_COUNT </B> <DD> Invalid count argument. Count arguments must be
|
||||
non-negative; a count of zero is often valid.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_RANK </B> <DD> Invalid source or destination rank. Ranks must be between
|
||||
zero and the size of the communicator minus one; ranks in a receive
|
||||
(<tt>MPI_Recv</tt>, <tt>MPI_Irecv</tt>, <tt>MPI_Sendrecv</tt>, etc.) may also be <tt>MPI_ANY_SOURCE</tt>.
|
||||
(<TT>MPI_Recv</TT>, <TT>MPI_Irecv</TT>, <TT>MPI_Sendrecv</TT>, etc.) may also be <TT>MPI_ANY_SOURCE</TT>.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_TYPE </B> <DD> Invalid datatype argument. Additionally, this error can
|
||||
occur if an uncommitted MPI_Datatype (see <tt>MPI_Type_commit</tt>) is used
|
||||
occur if an uncommitted MPI_Datatype (see <TT>MPI_Type_commit</TT>) is used
|
||||
in a communication call.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_WIN </B> <DD> Invalid MPI window object
|
||||
</DL>
|
||||
<P>
|
||||
<H0>See Also</H0>
|
||||
<H2>See Also</H2>
|
||||
MPI_Raccumulate
|
||||
<br>
|
||||
<BR>
|
||||
</BODY></HTML>
|
||||
|
||||
@@ -20,37 +20,37 @@ int MPI_Add_error_class(int *errorclass)
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
this is due to the use of memory allocation routines such as <TT>malloc
|
||||
</TT>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
All MPI routines in Fortran (except for <TT>MPI_WTIME</TT> and <TT>MPI_WTICK</TT>) have
|
||||
an additional argument <TT>ierr</TT> at the end of the argument list. <TT>ierr
|
||||
</TT>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<TT>call</TT> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
All MPI objects (e.g., <TT>MPI_Datatype</TT>, <TT>MPI_Comm</TT>) are of type <TT>INTEGER
|
||||
</TT>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
All MPI routines (except <TT>MPI_Wtime</TT> and <TT>MPI_Wtick</TT>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
may be changed with <TT>MPI_Comm_set_errhandler</TT> (for communicators),
|
||||
<TT>MPI_File_set_errhandler</TT> (for files), and <TT>MPI_Win_set_errhandler</TT> (for
|
||||
RMA windows). The MPI-1 routine <TT>MPI_Errhandler_set</TT> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarentee that an MPI program can continue past
|
||||
<TT>MPI_ERRORS_RETURN</TT> may be used to cause error values to be returned.
|
||||
Note that MPI does <EM>not</EM> guarentee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL><DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_OTHER </B> <DD> Other error; use <tt>MPI_Error_string</tt> to get more information
|
||||
<DL><DT><B>MPI_ERR_OTHER </B> <DD> Other error; use <TT>MPI_Error_string</TT> to get more information
|
||||
about this error code.
|
||||
</DL>
|
||||
</BODY></HTML>
|
||||
|
||||
@@ -24,37 +24,37 @@ int MPI_Add_error_code(int errorclass, int *errorcode)
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
this is due to the use of memory allocation routines such as <TT>malloc
|
||||
</TT>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
All MPI routines in Fortran (except for <TT>MPI_WTIME</TT> and <TT>MPI_WTICK</TT>) have
|
||||
an additional argument <TT>ierr</TT> at the end of the argument list. <TT>ierr
|
||||
</TT>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<TT>call</TT> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
All MPI objects (e.g., <TT>MPI_Datatype</TT>, <TT>MPI_Comm</TT>) are of type <TT>INTEGER
|
||||
</TT>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
All MPI routines (except <TT>MPI_Wtime</TT> and <TT>MPI_Wtick</TT>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
may be changed with <TT>MPI_Comm_set_errhandler</TT> (for communicators),
|
||||
<TT>MPI_File_set_errhandler</TT> (for files), and <TT>MPI_Win_set_errhandler</TT> (for
|
||||
RMA windows). The MPI-1 routine <TT>MPI_Errhandler_set</TT> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarentee that an MPI program can continue past
|
||||
<TT>MPI_ERRORS_RETURN</TT> may be used to cause error values to be returned.
|
||||
Note that MPI does <EM>not</EM> guarentee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL><DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_OTHER </B> <DD> Other error; use <tt>MPI_Error_string</tt> to get more information
|
||||
<DL><DT><B>MPI_ERR_OTHER </B> <DD> Other error; use <TT>MPI_Error_string</TT> to get more information
|
||||
about this error code.
|
||||
</DL>
|
||||
</BODY></HTML>
|
||||
|
||||
@@ -19,15 +19,15 @@ int MPI_Add_error_string(int errorcode, const char *string)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Notes</H2>
|
||||
The string must be no more than <tt>MPI_MAX_ERROR_STRING</tt> characters long.
|
||||
The string must be no more than <TT>MPI_MAX_ERROR_STRING</TT> characters long.
|
||||
The length of the string is as defined in the calling language.
|
||||
The length of the string does not include the null terminator in C or C++.
|
||||
Note that the string is <tt>const</tt> even though the MPI standard does not
|
||||
Note that the string is <TT>const</TT> even though the MPI standard does not
|
||||
specify it that way.
|
||||
<P>
|
||||
According to the MPI-2 standard, it is erroneous to call <tt>MPI_Add_error_string
|
||||
</tt>for an error code or class with a value less than or equal
|
||||
to <tt>MPI_ERR_LASTCODE</tt>. Thus, you cannot replace the predefined error messages
|
||||
According to the MPI-2 standard, it is erroneous to call <TT>MPI_Add_error_string
|
||||
</TT>for an error code or class with a value less than or equal
|
||||
to <TT>MPI_ERR_LASTCODE</TT>. Thus, you cannot replace the predefined error messages
|
||||
with this routine.
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
@@ -35,31 +35,31 @@ with this routine.
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
this is due to the use of memory allocation routines such as <TT>malloc
|
||||
</TT>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
All MPI routines in Fortran (except for <TT>MPI_WTIME</TT> and <TT>MPI_WTICK</TT>) have
|
||||
an additional argument <TT>ierr</TT> at the end of the argument list. <TT>ierr
|
||||
</TT>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<TT>call</TT> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
All MPI objects (e.g., <TT>MPI_Datatype</TT>, <TT>MPI_Comm</TT>) are of type <TT>INTEGER
|
||||
</TT>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
All MPI routines (except <TT>MPI_Wtime</TT> and <TT>MPI_Wtick</TT>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
may be changed with <TT>MPI_Comm_set_errhandler</TT> (for communicators),
|
||||
<TT>MPI_File_set_errhandler</TT> (for files), and <TT>MPI_Win_set_errhandler</TT> (for
|
||||
RMA windows). The MPI-1 routine <TT>MPI_Errhandler_set</TT> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarentee that an MPI program can continue past
|
||||
<TT>MPI_ERRORS_RETURN</TT> may be used to cause error values to be returned.
|
||||
Note that MPI does <EM>not</EM> guarentee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
|
||||
@@ -9,7 +9,7 @@
|
||||
Gets the address of a location in memory
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
int MPI_Address(void *location, MPI_Aint *address)
|
||||
int MPI_Address(void *location, MPI_Aint * address)
|
||||
</PRE>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL><DT><B>location </B> <DD> location in caller memory (choice)
|
||||
@@ -22,7 +22,7 @@ int MPI_Address(void *location, MPI_Aint *address)
|
||||
<H2>Note</H2>
|
||||
This routine is provided for both the Fortran and C programmers.
|
||||
On many systems, the address returned by this routine will be the same
|
||||
as produced by the C <tt>&</tt> operator, but this is not required in C and
|
||||
as produced by the C <TT>&</TT> operator, but this is not required in C and
|
||||
may not be true of systems with word- rather than byte-oriented
|
||||
instructions or systems with segmented address spaces.
|
||||
<P>
|
||||
@@ -37,36 +37,36 @@ The MPI-2 standard deprecated a number of routines because MPI-2 provides
|
||||
better versions. This routine is one of those that was deprecated. The
|
||||
routine may continue to be used, but new code should use the replacement
|
||||
routine.
|
||||
The replacement for this routine is <tt>MPI_Get_address</tt>.
|
||||
The replacement for this routine is <TT>MPI_Get_address</TT>.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
All MPI routines in Fortran (except for <TT>MPI_WTIME</TT> and <TT>MPI_WTICK</TT>) have
|
||||
an additional argument <TT>ierr</TT> at the end of the argument list. <TT>ierr
|
||||
</TT>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<TT>call</TT> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
All MPI objects (e.g., <TT>MPI_Datatype</TT>, <TT>MPI_Comm</TT>) are of type <TT>INTEGER
|
||||
</TT>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
All MPI routines (except <TT>MPI_Wtime</TT> and <TT>MPI_Wtick</TT>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
may be changed with <TT>MPI_Comm_set_errhandler</TT> (for communicators),
|
||||
<TT>MPI_File_set_errhandler</TT> (for files), and <TT>MPI_Win_set_errhandler</TT> (for
|
||||
RMA windows). The MPI-1 routine <TT>MPI_Errhandler_set</TT> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarentee that an MPI program can continue past
|
||||
<TT>MPI_ERRORS_RETURN</TT> may be used to cause error values to be returned.
|
||||
Note that MPI does <EM>not</EM> guarentee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL><DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_OTHER </B> <DD> Other error; use <tt>MPI_Error_string</tt> to get more information
|
||||
<DL><DT><B>MPI_ERR_OTHER </B> <DD> Other error; use <TT>MPI_Error_string</TT> to get more information
|
||||
about this error code.
|
||||
</DL>
|
||||
</BODY></HTML>
|
||||
|
||||
@@ -34,7 +34,7 @@ as if the process that originally produced base had called:
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
<H0>See Also</H0>
|
||||
<H2>See Also</H2>
|
||||
MPI_Aint_diff
|
||||
<br>
|
||||
<BR>
|
||||
</BODY></HTML>
|
||||
|
||||
@@ -35,7 +35,7 @@ process that originally produced the addresses had called
|
||||
|
||||
on the addresses initially passed to MPI_GET_ADDRESS.
|
||||
<P>
|
||||
<H0>See Also</H0>
|
||||
<H2>See Also</H2>
|
||||
MPI_Aint_add
|
||||
<br>
|
||||
<BR>
|
||||
</BODY></HTML>
|
||||
|
||||
@@ -10,8 +10,7 @@ Gathers data from all tasks and distribute the combined data to all tasks
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
int MPI_Allgather(const void *sendbuf, int sendcount, MPI_Datatype sendtype,
|
||||
void *recvbuf, int recvcount, MPI_Datatype recvtype,
|
||||
MPI_Comm comm)
|
||||
void *recvbuf, int recvcount, MPI_Datatype recvtype, MPI_Comm comm)
|
||||
</PRE>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
@@ -34,26 +33,26 @@ int MPI_Allgather(const void *sendbuf, int sendcount, MPI_Datatype sendtype,
|
||||
<P>
|
||||
<H2>Notes</H2>
|
||||
The MPI standard (1.0 and 1.1) says that
|
||||
<br>
|
||||
<BR>
|
||||
<P>
|
||||
<br>
|
||||
<BR>
|
||||
<P>
|
||||
The jth block of data sent from each process is received by every process
|
||||
and placed in the jth block of the buffer <tt>recvbuf</tt>.
|
||||
<br>
|
||||
and placed in the jth block of the buffer <TT>recvbuf</TT>.
|
||||
<BR>
|
||||
<P>
|
||||
<br>
|
||||
<BR>
|
||||
<P>
|
||||
This is misleading; a better description is
|
||||
<br>
|
||||
<BR>
|
||||
<P>
|
||||
<br>
|
||||
<BR>
|
||||
<P>
|
||||
The block of data sent from the jth process is received by every
|
||||
process and placed in the jth block of the buffer <tt>recvbuf</tt>.
|
||||
<br>
|
||||
process and placed in the jth block of the buffer <TT>recvbuf</TT>.
|
||||
<BR>
|
||||
<P>
|
||||
<br>
|
||||
<BR>
|
||||
<P>
|
||||
This text was suggested by Rajeev Thakur and has been adopted as a
|
||||
clarification by the MPI Forum.
|
||||
@@ -63,42 +62,42 @@ clarification by the MPI Forum.
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
this is due to the use of memory allocation routines such as <TT>malloc
|
||||
</TT>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
All MPI routines in Fortran (except for <TT>MPI_WTIME</TT> and <TT>MPI_WTICK</TT>) have
|
||||
an additional argument <TT>ierr</TT> at the end of the argument list. <TT>ierr
|
||||
</TT>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<TT>call</TT> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
All MPI objects (e.g., <TT>MPI_Datatype</TT>, <TT>MPI_Comm</TT>) are of type <TT>INTEGER
|
||||
</TT>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
All MPI routines (except <TT>MPI_Wtime</TT> and <TT>MPI_Wtick</TT>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
may be changed with <TT>MPI_Comm_set_errhandler</TT> (for communicators),
|
||||
<TT>MPI_File_set_errhandler</TT> (for files), and <TT>MPI_Win_set_errhandler</TT> (for
|
||||
RMA windows). The MPI-1 routine <TT>MPI_Errhandler_set</TT> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarentee that an MPI program can continue past
|
||||
<TT>MPI_ERRORS_RETURN</TT> may be used to cause error values to be returned.
|
||||
Note that MPI does <EM>not</EM> guarentee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL><DT><B>MPI_ERR_COMM </B> <DD> Invalid communicator. A common error is to use a null
|
||||
communicator in a call (not even allowed in <tt>MPI_Comm_rank</tt>).
|
||||
communicator in a call (not even allowed in <TT>MPI_Comm_rank</TT>).
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_COUNT </B> <DD> Invalid count argument. Count arguments must be
|
||||
non-negative; a count of zero is often valid.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_TYPE </B> <DD> Invalid datatype argument. Additionally, this error can
|
||||
occur if an uncommitted MPI_Datatype (see <tt>MPI_Type_commit</tt>) is used
|
||||
occur if an uncommitted MPI_Datatype (see <TT>MPI_Type_commit</TT>) is used
|
||||
in a communication call.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_BUFFER </B> <DD> Invalid buffer pointer. Usually a null buffer where
|
||||
|
||||
@@ -25,9 +25,9 @@ int MPI_Allgatherv(const void *sendbuf, int sendcount, MPI_Datatype sendtype,
|
||||
containing the number of elements that are to be received from each process
|
||||
|
||||
<DT><B>displs </B><DD>integer array (of length group size). Entry
|
||||
<tt>i</tt> specifies the displacement (relative to recvbuf ) at
|
||||
which to place the incoming data from process <tt>i</tt>
|
||||
|
||||
<TT>i</TT> specifies the displacement (relative to recvbuf) at
|
||||
which to place the incoming data from process <TT>i
|
||||
</TT>
|
||||
<DT><B>recvtype </B><DD>data type of receive buffer elements (handle)
|
||||
|
||||
<DT><B>comm </B><DD>communicator (handle)
|
||||
@@ -39,27 +39,27 @@ which to place the incoming data from process <tt>i</tt>
|
||||
<P>
|
||||
<H2>Notes</H2>
|
||||
The MPI standard (1.0 and 1.1) says that
|
||||
<br>
|
||||
<BR>
|
||||
<P>
|
||||
<br>
|
||||
<BR>
|
||||
<P>
|
||||
The jth block of data sent from
|
||||
each process is received by every process and placed in the jth block of the
|
||||
buffer <tt>recvbuf</tt>.
|
||||
<br>
|
||||
buffer <TT>recvbuf</TT>.
|
||||
<BR>
|
||||
<P>
|
||||
<br>
|
||||
<BR>
|
||||
<P>
|
||||
This is misleading; a better description is
|
||||
<br>
|
||||
<BR>
|
||||
<P>
|
||||
<br>
|
||||
<BR>
|
||||
<P>
|
||||
The block of data sent from the jth process is received by every
|
||||
process and placed in the jth block of the buffer <tt>recvbuf</tt>.
|
||||
<br>
|
||||
process and placed in the jth block of the buffer <TT>recvbuf</TT>.
|
||||
<BR>
|
||||
<P>
|
||||
<br>
|
||||
<BR>
|
||||
<P>
|
||||
This text was suggested by Rajeev Thakur, and has been adopted as a
|
||||
clarification to the MPI standard by the MPI-Forum.
|
||||
@@ -69,31 +69,31 @@ clarification to the MPI standard by the MPI-Forum.
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
this is due to the use of memory allocation routines such as <TT>malloc
|
||||
</TT>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
All MPI routines in Fortran (except for <TT>MPI_WTIME</TT> and <TT>MPI_WTICK</TT>) have
|
||||
an additional argument <TT>ierr</TT> at the end of the argument list. <TT>ierr
|
||||
</TT>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<TT>call</TT> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
All MPI objects (e.g., <TT>MPI_Datatype</TT>, <TT>MPI_Comm</TT>) are of type <TT>INTEGER
|
||||
</TT>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
All MPI routines (except <TT>MPI_Wtime</TT> and <TT>MPI_Wtick</TT>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
may be changed with <TT>MPI_Comm_set_errhandler</TT> (for communicators),
|
||||
<TT>MPI_File_set_errhandler</TT> (for files), and <TT>MPI_Win_set_errhandler</TT> (for
|
||||
RMA windows). The MPI-1 routine <TT>MPI_Errhandler_set</TT> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarentee that an MPI program can continue past
|
||||
<TT>MPI_ERRORS_RETURN</TT> may be used to cause error values to be returned.
|
||||
Note that MPI does <EM>not</EM> guarentee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
@@ -104,7 +104,7 @@ one is not valid.
|
||||
non-negative; a count of zero is often valid.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_TYPE </B> <DD> Invalid datatype argument. Additionally, this error can
|
||||
occur if an uncommitted MPI_Datatype (see <tt>MPI_Type_commit</tt>) is used
|
||||
occur if an uncommitted MPI_Datatype (see <TT>MPI_Type_commit</TT>) is used
|
||||
in a communication call.
|
||||
</DL>
|
||||
</BODY></HTML>
|
||||
|
||||
@@ -27,9 +27,9 @@ Using this routine from Fortran requires that the Fortran compiler accept
|
||||
a common pointer extension. See Section 4.11 (Memory Allocation) in the
|
||||
MPI-2 standard for more information and examples.
|
||||
<P>
|
||||
Also note that while <tt>baseptr</tt> is a <tt>void *</tt> type, this is
|
||||
Also note that while <TT>baseptr</TT> is a <TT>void *</TT> type, this is
|
||||
simply to allow easy use of any pointer object for this parameter.
|
||||
In fact, this argument is really a <tt>void **</tt> type, that is, a
|
||||
In fact, this argument is really a <TT>void **</TT> type, that is, a
|
||||
pointer to a pointer.
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
@@ -37,31 +37,31 @@ pointer to a pointer.
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
this is due to the use of memory allocation routines such as <TT>malloc
|
||||
</TT>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
All MPI routines in Fortran (except for <TT>MPI_WTIME</TT> and <TT>MPI_WTICK</TT>) have
|
||||
an additional argument <TT>ierr</TT> at the end of the argument list. <TT>ierr
|
||||
</TT>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<TT>call</TT> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
All MPI objects (e.g., <TT>MPI_Datatype</TT>, <TT>MPI_Comm</TT>) are of type <TT>INTEGER
|
||||
</TT>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
All MPI routines (except <TT>MPI_Wtime</TT> and <TT>MPI_Wtick</TT>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
may be changed with <TT>MPI_Comm_set_errhandler</TT> (for communicators),
|
||||
<TT>MPI_File_set_errhandler</TT> (for files), and <TT>MPI_Win_set_errhandler</TT> (for
|
||||
RMA windows). The MPI-1 routine <TT>MPI_Errhandler_set</TT> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarentee that an MPI program can continue past
|
||||
<TT>MPI_ERRORS_RETURN</TT> may be used to cause error values to be returned.
|
||||
Note that MPI does <EM>not</EM> guarentee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
@@ -70,10 +70,10 @@ possible.
|
||||
<DL><DT><B>MPI_ERR_INFO </B> <DD> Invalid Info
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_ARG </B> <DD> Invalid argument. Some argument is invalid and is not
|
||||
identified by a specific error class (e.g., <tt>MPI_ERR_RANK</tt>).
|
||||
identified by a specific error class (e.g., <TT>MPI_ERR_RANK</TT>).
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_NO_MEM </B> <DD> Insufficient memory available for allocation by
|
||||
<tt>MPI_Alloc_mem
|
||||
</tt>
|
||||
<TT>MPI_Alloc_mem
|
||||
</TT>
|
||||
</DL>
|
||||
</BODY></HTML>
|
||||
|
||||
@@ -34,25 +34,25 @@ int MPI_Allreduce(const void *sendbuf, void *recvbuf, int count,
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
this is due to the use of memory allocation routines such as <TT>malloc
|
||||
</TT>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
All MPI routines in Fortran (except for <TT>MPI_WTIME</TT> and <TT>MPI_WTICK</TT>) have
|
||||
an additional argument <TT>ierr</TT> at the end of the argument list. <TT>ierr
|
||||
</TT>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<TT>call</TT> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
All MPI objects (e.g., <TT>MPI_Datatype</TT>, <TT>MPI_Comm</TT>) are of type <TT>INTEGER
|
||||
</TT>in Fortran.
|
||||
<P>
|
||||
<H2>Notes on collective operations</H2>
|
||||
<P>
|
||||
The reduction functions (<tt>MPI_Op</tt>) do not return an error value. As a result,
|
||||
if the functions detect an error, all they can do is either call <tt>MPI_Abort
|
||||
</tt>or silently skip the problem. Thus, if you change the error handler from
|
||||
<tt>MPI_ERRORS_ARE_FATAL</tt> to something else, for example, <tt>MPI_ERRORS_RETURN</tt>,
|
||||
The reduction functions (<TT>MPI_Op</TT>) do not return an error value. As a result,
|
||||
if the functions detect an error, all they can do is either call <TT>MPI_Abort
|
||||
</TT>or silently skip the problem. Thus, if you change the error handler from
|
||||
<TT>MPI_ERRORS_ARE_FATAL</TT> to something else, for example, <TT>MPI_ERRORS_RETURN</TT>,
|
||||
then no error may be indicated.
|
||||
<P>
|
||||
The reason for this is the performance problems in ensuring that
|
||||
@@ -60,16 +60,16 @@ all collective routines return the same error value.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
All MPI routines (except <TT>MPI_Wtime</TT> and <TT>MPI_Wtick</TT>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
may be changed with <TT>MPI_Comm_set_errhandler</TT> (for communicators),
|
||||
<TT>MPI_File_set_errhandler</TT> (for files), and <TT>MPI_Win_set_errhandler</TT> (for
|
||||
RMA windows). The MPI-1 routine <TT>MPI_Errhandler_set</TT> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarentee that an MPI program can continue past
|
||||
<TT>MPI_ERRORS_RETURN</TT> may be used to cause error values to be returned.
|
||||
Note that MPI does <EM>not</EM> guarentee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
@@ -80,14 +80,14 @@ one is not valid.
|
||||
non-negative; a count of zero is often valid.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_TYPE </B> <DD> Invalid datatype argument. Additionally, this error can
|
||||
occur if an uncommitted MPI_Datatype (see <tt>MPI_Type_commit</tt>) is used
|
||||
occur if an uncommitted MPI_Datatype (see <TT>MPI_Type_commit</TT>) is used
|
||||
in a communication call.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_OP </B> <DD> Invalid operation. MPI operations (objects of type <tt>MPI_Op</tt>)
|
||||
must either be one of the predefined operations (e.g., <tt>MPI_SUM</tt>) or
|
||||
created with <tt>MPI_Op_create</tt>.
|
||||
<DL><DT><B>MPI_ERR_OP </B> <DD> Invalid operation. MPI operations (objects of type <TT>MPI_Op</TT>)
|
||||
must either be one of the predefined operations (e.g., <TT>MPI_SUM</TT>) or
|
||||
created with <TT>MPI_Op_create</TT>.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_COMM </B> <DD> Invalid communicator. A common error is to use a null
|
||||
communicator in a call (not even allowed in <tt>MPI_Comm_rank</tt>).
|
||||
communicator in a call (not even allowed in <TT>MPI_Comm_rank</TT>).
|
||||
</DL>
|
||||
</BODY></HTML>
|
||||
|
||||
@@ -10,8 +10,7 @@ Sends data from all to all processes
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
int MPI_Alltoall(const void *sendbuf, int sendcount, MPI_Datatype sendtype,
|
||||
void *recvbuf, int recvcount, MPI_Datatype recvtype,
|
||||
MPI_Comm comm)
|
||||
void *recvbuf, int recvcount, MPI_Datatype recvtype, MPI_Comm comm)
|
||||
</PRE>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
@@ -37,42 +36,42 @@ int MPI_Alltoall(const void *sendbuf, int sendcount, MPI_Datatype sendtype,
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
this is due to the use of memory allocation routines such as <TT>malloc
|
||||
</TT>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
All MPI routines in Fortran (except for <TT>MPI_WTIME</TT> and <TT>MPI_WTICK</TT>) have
|
||||
an additional argument <TT>ierr</TT> at the end of the argument list. <TT>ierr
|
||||
</TT>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<TT>call</TT> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
All MPI objects (e.g., <TT>MPI_Datatype</TT>, <TT>MPI_Comm</TT>) are of type <TT>INTEGER
|
||||
</TT>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
All MPI routines (except <TT>MPI_Wtime</TT> and <TT>MPI_Wtick</TT>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
may be changed with <TT>MPI_Comm_set_errhandler</TT> (for communicators),
|
||||
<TT>MPI_File_set_errhandler</TT> (for files), and <TT>MPI_Win_set_errhandler</TT> (for
|
||||
RMA windows). The MPI-1 routine <TT>MPI_Errhandler_set</TT> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarentee that an MPI program can continue past
|
||||
<TT>MPI_ERRORS_RETURN</TT> may be used to cause error values to be returned.
|
||||
Note that MPI does <EM>not</EM> guarentee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL><DT><B>MPI_ERR_COMM </B> <DD> Invalid communicator. A common error is to use a null
|
||||
communicator in a call (not even allowed in <tt>MPI_Comm_rank</tt>).
|
||||
communicator in a call (not even allowed in <TT>MPI_Comm_rank</TT>).
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_COUNT </B> <DD> Invalid count argument. Count arguments must be
|
||||
non-negative; a count of zero is often valid.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_TYPE </B> <DD> Invalid datatype argument. Additionally, this error can
|
||||
occur if an uncommitted MPI_Datatype (see <tt>MPI_Type_commit</tt>) is used
|
||||
occur if an uncommitted MPI_Datatype (see <TT>MPI_Type_commit</TT>) is used
|
||||
in a communication call.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_BUFFER </B> <DD> Invalid buffer pointer. Usually a null buffer where
|
||||
|
||||
@@ -11,8 +11,7 @@ Sends data from all to all processes; each process may send a different amount
|
||||
<PRE>
|
||||
int MPI_Alltoallv(const void *sendbuf, const int *sendcounts,
|
||||
const int *sdispls, MPI_Datatype sendtype, void *recvbuf,
|
||||
const int *recvcounts, const int *rdispls, MPI_Datatype recvtype,
|
||||
MPI_Comm comm)
|
||||
const int *recvcounts, const int *rdispls, MPI_Datatype recvtype, MPI_Comm comm)
|
||||
</PRE>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
@@ -22,9 +21,9 @@ int MPI_Alltoallv(const void *sendbuf, const int *sendcounts,
|
||||
specifying the number of elements to send to each processor
|
||||
|
||||
<DT><B>sdispls </B><DD>integer array (of length group size). Entry
|
||||
<tt>j</tt> specifies the displacement (relative to sendbuf from
|
||||
which to take the outgoing data destined for process <tt>j</tt>
|
||||
|
||||
<TT>j</TT> specifies the displacement (relative to sendbuf from
|
||||
which to take the outgoing data destined for process <TT>j
|
||||
</TT>
|
||||
<DT><B>sendtype </B><DD>data type of send buffer elements (handle)
|
||||
|
||||
<DT><B>recvcounts </B><DD>integer array equal to the group size
|
||||
@@ -32,9 +31,9 @@ specifying the maximum number of elements that can be received from
|
||||
each processor
|
||||
|
||||
<DT><B>rdispls </B><DD>integer array (of length group size). Entry
|
||||
<tt>i</tt> specifies the displacement (relative to recvbuf at
|
||||
which to place the incoming data from process <tt>i</tt>
|
||||
|
||||
<TT>i</TT> specifies the displacement (relative to recvbuf at
|
||||
which to place the incoming data from process <TT>i
|
||||
</TT>
|
||||
<DT><B>recvtype </B><DD>data type of receive buffer elements (handle)
|
||||
|
||||
<DT><B>comm </B><DD>communicator (handle)
|
||||
@@ -49,42 +48,42 @@ which to place the incoming data from process <tt>i</tt>
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
this is due to the use of memory allocation routines such as <TT>malloc
|
||||
</TT>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
All MPI routines in Fortran (except for <TT>MPI_WTIME</TT> and <TT>MPI_WTICK</TT>) have
|
||||
an additional argument <TT>ierr</TT> at the end of the argument list. <TT>ierr
|
||||
</TT>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<TT>call</TT> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
All MPI objects (e.g., <TT>MPI_Datatype</TT>, <TT>MPI_Comm</TT>) are of type <TT>INTEGER
|
||||
</TT>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
All MPI routines (except <TT>MPI_Wtime</TT> and <TT>MPI_Wtick</TT>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
may be changed with <TT>MPI_Comm_set_errhandler</TT> (for communicators),
|
||||
<TT>MPI_File_set_errhandler</TT> (for files), and <TT>MPI_Win_set_errhandler</TT> (for
|
||||
RMA windows). The MPI-1 routine <TT>MPI_Errhandler_set</TT> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarentee that an MPI program can continue past
|
||||
<TT>MPI_ERRORS_RETURN</TT> may be used to cause error values to be returned.
|
||||
Note that MPI does <EM>not</EM> guarentee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL><DT><B>MPI_ERR_COMM </B> <DD> Invalid communicator. A common error is to use a null
|
||||
communicator in a call (not even allowed in <tt>MPI_Comm_rank</tt>).
|
||||
communicator in a call (not even allowed in <TT>MPI_Comm_rank</TT>).
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_COUNT </B> <DD> Invalid count argument. Count arguments must be
|
||||
non-negative; a count of zero is often valid.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_TYPE </B> <DD> Invalid datatype argument. Additionally, this error can
|
||||
occur if an uncommitted MPI_Datatype (see <tt>MPI_Type_commit</tt>) is used
|
||||
occur if an uncommitted MPI_Datatype (see <TT>MPI_Type_commit</TT>) is used
|
||||
in a communication call.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_BUFFER </B> <DD> Invalid buffer pointer. Usually a null buffer where
|
||||
|
||||
@@ -50,47 +50,47 @@ the type of data received from process i (handle)
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
this is due to the use of memory allocation routines such as <TT>malloc
|
||||
</TT>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
All MPI routines in Fortran (except for <TT>MPI_WTIME</TT> and <TT>MPI_WTICK</TT>) have
|
||||
an additional argument <TT>ierr</TT> at the end of the argument list. <TT>ierr
|
||||
</TT>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<TT>call</TT> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
All MPI objects (e.g., <TT>MPI_Datatype</TT>, <TT>MPI_Comm</TT>) are of type <TT>INTEGER
|
||||
</TT>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
All MPI routines (except <TT>MPI_Wtime</TT> and <TT>MPI_Wtick</TT>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
may be changed with <TT>MPI_Comm_set_errhandler</TT> (for communicators),
|
||||
<TT>MPI_File_set_errhandler</TT> (for files), and <TT>MPI_Win_set_errhandler</TT> (for
|
||||
RMA windows). The MPI-1 routine <TT>MPI_Errhandler_set</TT> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarentee that an MPI program can continue past
|
||||
<TT>MPI_ERRORS_RETURN</TT> may be used to cause error values to be returned.
|
||||
Note that MPI does <EM>not</EM> guarentee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL><DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_COMM </B> <DD> Invalid communicator. A common error is to use a null
|
||||
communicator in a call (not even allowed in <tt>MPI_Comm_rank</tt>).
|
||||
communicator in a call (not even allowed in <TT>MPI_Comm_rank</TT>).
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_ARG </B> <DD> Invalid argument. Some argument is invalid and is not
|
||||
identified by a specific error class (e.g., <tt>MPI_ERR_RANK</tt>).
|
||||
identified by a specific error class (e.g., <TT>MPI_ERR_RANK</TT>).
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_COUNT </B> <DD> Invalid count argument. Count arguments must be
|
||||
non-negative; a count of zero is often valid.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_TYPE </B> <DD> Invalid datatype argument. Additionally, this error can
|
||||
occur if an uncommitted MPI_Datatype (see <tt>MPI_Type_commit</tt>) is used
|
||||
occur if an uncommitted MPI_Datatype (see <TT>MPI_Type_commit</TT>) is used
|
||||
in a communication call.
|
||||
</DL>
|
||||
</BODY></HTML>
|
||||
|
||||
@@ -23,45 +23,45 @@ int MPI_Attr_delete(MPI_Comm comm, int keyval)
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
this is due to the use of memory allocation routines such as <TT>malloc
|
||||
</TT>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Deprecated Function</H2>
|
||||
The MPI-2 standard deprecated a number of routines because MPI-2 provides
|
||||
better versions. This routine is one of those that was deprecated. The
|
||||
routine may continue to be used, but new code should use the replacement
|
||||
routine.
|
||||
The replacement for this routine is <tt>MPI_Comm_delete_attr</tt>.
|
||||
The replacement for this routine is <TT>MPI_Comm_delete_attr</TT>.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
All MPI routines in Fortran (except for <TT>MPI_WTIME</TT> and <TT>MPI_WTICK</TT>) have
|
||||
an additional argument <TT>ierr</TT> at the end of the argument list. <TT>ierr
|
||||
</TT>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<TT>call</TT> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
All MPI objects (e.g., <TT>MPI_Datatype</TT>, <TT>MPI_Comm</TT>) are of type <TT>INTEGER
|
||||
</TT>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
All MPI routines (except <TT>MPI_Wtime</TT> and <TT>MPI_Wtick</TT>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
may be changed with <TT>MPI_Comm_set_errhandler</TT> (for communicators),
|
||||
<TT>MPI_File_set_errhandler</TT> (for files), and <TT>MPI_Win_set_errhandler</TT> (for
|
||||
RMA windows). The MPI-1 routine <TT>MPI_Errhandler_set</TT> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarentee that an MPI program can continue past
|
||||
<TT>MPI_ERRORS_RETURN</TT> may be used to cause error values to be returned.
|
||||
Note that MPI does <EM>not</EM> guarentee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL><DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_COMM </B> <DD> Invalid communicator. A common error is to use a null
|
||||
communicator in a call (not even allowed in <tt>MPI_Comm_rank</tt>).
|
||||
communicator in a call (not even allowed in <TT>MPI_Comm_rank</TT>).
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_ARG </B> <DD> This error class is associated with an error code that
|
||||
indicates that an attempt was made to free one of the permanent keys.
|
||||
|
||||
@@ -20,7 +20,7 @@ int MPI_Attr_get(MPI_Comm comm, int keyval, void *attribute_val, int *flag)
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>attribute_val </B><DD>attribute value, unless <tt>flag</tt> = false
|
||||
<DT><B>attribute_val </B><DD>attribute value, unless <TT>flag</TT> = false
|
||||
|
||||
<DT><B>flag </B><DD>true if an attribute value was extracted; false if no attribute is
|
||||
associated with the key
|
||||
@@ -28,12 +28,12 @@ associated with the key
|
||||
<P>
|
||||
<H2>Notes</H2>
|
||||
Attributes must be extracted from the same language as they were inserted
|
||||
in with <tt>MPI_ATTR_PUT</tt>. The notes for C and Fortran below explain why.
|
||||
in with <TT>MPI_ATTR_PUT</TT>. The notes for C and Fortran below explain why.
|
||||
<P>
|
||||
<H2>Notes for C</H2>
|
||||
Even though the <tt>attribute_val</tt> argument is declared as <tt>void *</tt>, it is
|
||||
really the address of a void pointer (i.e., a <tt>void **</tt>). Using
|
||||
a <tt>void *</tt>, however, is more in keeping with C idiom and allows the
|
||||
Even though the <TT>attribute_val</TT> argument is declared as <TT>void *</TT>, it is
|
||||
really the address of a void pointer (i.e., a <TT>void **</TT>). Using
|
||||
a <TT>void *</TT>, however, is more in keeping with C idiom and allows the
|
||||
pointer to be passed without additional casts.
|
||||
<P>
|
||||
<P>
|
||||
@@ -42,53 +42,53 @@ pointer to be passed without additional casts.
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
this is due to the use of memory allocation routines such as <TT>malloc
|
||||
</TT>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Deprecated Function</H2>
|
||||
The MPI-2 standard deprecated a number of routines because MPI-2 provides
|
||||
better versions. This routine is one of those that was deprecated. The
|
||||
routine may continue to be used, but new code should use the replacement
|
||||
routine.
|
||||
The replacement for this routine is <tt>MPI_Comm_get_attr</tt>.
|
||||
The replacement for this routine is <TT>MPI_Comm_get_attr</TT>.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
All MPI routines in Fortran (except for <TT>MPI_WTIME</TT> and <TT>MPI_WTICK</TT>) have
|
||||
an additional argument <TT>ierr</TT> at the end of the argument list. <TT>ierr
|
||||
</TT>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<TT>call</TT> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
All MPI objects (e.g., <TT>MPI_Datatype</TT>, <TT>MPI_Comm</TT>) are of type <TT>INTEGER
|
||||
</TT>in Fortran.
|
||||
<P>
|
||||
The <tt>attribute_val</tt> in Fortran is a pointer to a Fortran integer, not
|
||||
a pointer to a <tt>void *</tt>.
|
||||
The <TT>attribute_val</TT> in Fortran is a pointer to a Fortran integer, not
|
||||
a pointer to a <TT>void *</TT>.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
All MPI routines (except <TT>MPI_Wtime</TT> and <TT>MPI_Wtick</TT>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
may be changed with <TT>MPI_Comm_set_errhandler</TT> (for communicators),
|
||||
<TT>MPI_File_set_errhandler</TT> (for files), and <TT>MPI_Win_set_errhandler</TT> (for
|
||||
RMA windows). The MPI-1 routine <TT>MPI_Errhandler_set</TT> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarentee that an MPI program can continue past
|
||||
<TT>MPI_ERRORS_RETURN</TT> may be used to cause error values to be returned.
|
||||
Note that MPI does <EM>not</EM> guarentee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL><DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_COMM </B> <DD> Invalid communicator. A common error is to use a null
|
||||
communicator in a call (not even allowed in <tt>MPI_Comm_rank</tt>).
|
||||
communicator in a call (not even allowed in <TT>MPI_Comm_rank</TT>).
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_KEYVAL </B> <DD> Invalid keyval
|
||||
</DL>
|
||||
<P>
|
||||
<H0>See Also</H0>
|
||||
<H2>See Also</H2>
|
||||
MPI_Attr_put, MPI_Keyval_create, MPI_Attr_delete, MPI_Comm_get_attr
|
||||
<br>
|
||||
<BR>
|
||||
</BODY></HTML>
|
||||
|
||||
@@ -15,23 +15,23 @@ int MPI_Attr_put(MPI_Comm comm, int keyval, void *attribute_val)
|
||||
<DL>
|
||||
<DT><B>comm </B><DD>communicator to which attribute will be attached (handle)
|
||||
|
||||
<DT><B>keyval </B><DD>key value, as returned by <tt>MPI_KEYVAL_CREATE</tt> (integer)
|
||||
<DT><B>keyval </B><DD>key value, as returned by <TT>MPI_KEYVAL_CREATE</TT> (integer)
|
||||
|
||||
<DT><B>attribute_val </B><DD>attribute value
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Notes</H2>
|
||||
Values of the permanent attributes <tt>MPI_TAG_UB</tt>, <tt>MPI_HOST</tt>, <tt>MPI_IO</tt>,
|
||||
<tt>MPI_WTIME_IS_GLOBAL</tt>, <tt>MPI_UNIVERSE_SIZE</tt>, <tt>MPI_LASTUSEDCODE</tt>, and
|
||||
<tt>MPI_APPNUM</tt> may not be changed.
|
||||
Values of the permanent attributes <TT>MPI_TAG_UB</TT>, <TT>MPI_HOST</TT>, <TT>MPI_IO</TT>,
|
||||
<TT>MPI_WTIME_IS_GLOBAL</TT>, <TT>MPI_UNIVERSE_SIZE</TT>, <TT>MPI_LASTUSEDCODE</TT>, and
|
||||
<TT>MPI_APPNUM</TT> may not be changed.
|
||||
<P>
|
||||
The type of the attribute value depends on whether C, C++, or Fortran
|
||||
is being used.
|
||||
In C and C++, an attribute value is a pointer (<tt>void *</tt>); in Fortran,
|
||||
In C and C++, an attribute value is a pointer (<TT>void *</TT>); in Fortran,
|
||||
it is a single
|
||||
integer (<em>not</em> a pointer, since Fortran has no pointers and there are systems
|
||||
integer (<EM>not</EM> a pointer, since Fortran has no pointers and there are systems
|
||||
for which a pointer does not fit in an integer (e.g., any > 32 bit address
|
||||
system that uses 64 bits for Fortran <tt>DOUBLE PRECISION</tt>).
|
||||
system that uses 64 bits for Fortran <TT>DOUBLE PRECISION</TT>).
|
||||
<P>
|
||||
If an attribute is already present, the delete function (specified when the
|
||||
corresponding keyval was created) will be called.
|
||||
@@ -41,45 +41,45 @@ corresponding keyval was created) will be called.
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
this is due to the use of memory allocation routines such as <TT>malloc
|
||||
</TT>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Deprecated Function</H2>
|
||||
The MPI-2 standard deprecated a number of routines because MPI-2 provides
|
||||
better versions. This routine is one of those that was deprecated. The
|
||||
routine may continue to be used, but new code should use the replacement
|
||||
routine.
|
||||
The replacement for this routine is <tt>MPI_Comm_set_attr</tt>.
|
||||
The replacement for this routine is <TT>MPI_Comm_set_attr</TT>.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
All MPI routines in Fortran (except for <TT>MPI_WTIME</TT> and <TT>MPI_WTICK</TT>) have
|
||||
an additional argument <TT>ierr</TT> at the end of the argument list. <TT>ierr
|
||||
</TT>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<TT>call</TT> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
All MPI objects (e.g., <TT>MPI_Datatype</TT>, <TT>MPI_Comm</TT>) are of type <TT>INTEGER
|
||||
</TT>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
All MPI routines (except <TT>MPI_Wtime</TT> and <TT>MPI_Wtick</TT>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
may be changed with <TT>MPI_Comm_set_errhandler</TT> (for communicators),
|
||||
<TT>MPI_File_set_errhandler</TT> (for files), and <TT>MPI_Win_set_errhandler</TT> (for
|
||||
RMA windows). The MPI-1 routine <TT>MPI_Errhandler_set</TT> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarentee that an MPI program can continue past
|
||||
<TT>MPI_ERRORS_RETURN</TT> may be used to cause error values to be returned.
|
||||
Note that MPI does <EM>not</EM> guarentee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL><DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_COMM </B> <DD> Invalid communicator. A common error is to use a null
|
||||
communicator in a call (not even allowed in <tt>MPI_Comm_rank</tt>).
|
||||
communicator in a call (not even allowed in <TT>MPI_Comm_rank</TT>).
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_KEYVAL </B> <DD> Invalid keyval
|
||||
</DL>
|
||||
@@ -87,7 +87,7 @@ communicator in a call (not even allowed in <tt>MPI_Comm_rank</tt>).
|
||||
indicates that an attempt was made to free one of the permanent keys.
|
||||
</DL>
|
||||
<P>
|
||||
<H0>See Also</H0>
|
||||
<H2>See Also</H2>
|
||||
MPI_Attr_get, MPI_Keyval_create, MPI_Attr_delete, MPI_Comm_set_attr
|
||||
<br>
|
||||
<BR>
|
||||
</BODY></HTML>
|
||||
|
||||
@@ -9,7 +9,7 @@
|
||||
Blocks until all processes in the communicator have reached this routine.
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
int MPI_Barrier( MPI_Comm comm )
|
||||
int MPI_Barrier(MPI_Comm comm)
|
||||
</PRE>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL><DT><B>comm </B> <DD> communicator (handle)
|
||||
@@ -25,37 +25,37 @@ communicator have entered the call.
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
this is due to the use of memory allocation routines such as <TT>malloc
|
||||
</TT>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
All MPI routines in Fortran (except for <TT>MPI_WTIME</TT> and <TT>MPI_WTICK</TT>) have
|
||||
an additional argument <TT>ierr</TT> at the end of the argument list. <TT>ierr
|
||||
</TT>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<TT>call</TT> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
All MPI objects (e.g., <TT>MPI_Datatype</TT>, <TT>MPI_Comm</TT>) are of type <TT>INTEGER
|
||||
</TT>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
All MPI routines (except <TT>MPI_Wtime</TT> and <TT>MPI_Wtick</TT>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
may be changed with <TT>MPI_Comm_set_errhandler</TT> (for communicators),
|
||||
<TT>MPI_File_set_errhandler</TT> (for files), and <TT>MPI_Win_set_errhandler</TT> (for
|
||||
RMA windows). The MPI-1 routine <TT>MPI_Errhandler_set</TT> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarentee that an MPI program can continue past
|
||||
<TT>MPI_ERRORS_RETURN</TT> may be used to cause error values to be returned.
|
||||
Note that MPI does <EM>not</EM> guarentee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL><DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_COMM </B> <DD> Invalid communicator. A common error is to use a null
|
||||
communicator in a call (not even allowed in <tt>MPI_Comm_rank</tt>).
|
||||
communicator in a call (not even allowed in <TT>MPI_Comm_rank</TT>).
|
||||
</DL>
|
||||
</BODY></HTML>
|
||||
|
||||
@@ -9,8 +9,7 @@
|
||||
Broadcasts a message from the process with rank "root" to all other processes of the communicator
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
int MPI_Bcast( void *buffer, int count, MPI_Datatype datatype, int root,
|
||||
MPI_Comm comm )
|
||||
int MPI_Bcast(void *buffer, int count, MPI_Datatype datatype, int root, MPI_Comm comm)
|
||||
</PRE>
|
||||
<H2>Input/Output Parameters</H2>
|
||||
<DL><DT><B>buffer </B> <DD> starting address of buffer (choice)
|
||||
@@ -32,44 +31,44 @@ int MPI_Bcast( void *buffer, int count, MPI_Datatype datatype, int root,
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
this is due to the use of memory allocation routines such as <TT>malloc
|
||||
</TT>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
All MPI routines in Fortran (except for <TT>MPI_WTIME</TT> and <TT>MPI_WTICK</TT>) have
|
||||
an additional argument <TT>ierr</TT> at the end of the argument list. <TT>ierr
|
||||
</TT>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<TT>call</TT> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
All MPI objects (e.g., <TT>MPI_Datatype</TT>, <TT>MPI_Comm</TT>) are of type <TT>INTEGER
|
||||
</TT>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
All MPI routines (except <TT>MPI_Wtime</TT> and <TT>MPI_Wtick</TT>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
may be changed with <TT>MPI_Comm_set_errhandler</TT> (for communicators),
|
||||
<TT>MPI_File_set_errhandler</TT> (for files), and <TT>MPI_Win_set_errhandler</TT> (for
|
||||
RMA windows). The MPI-1 routine <TT>MPI_Errhandler_set</TT> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarentee that an MPI program can continue past
|
||||
<TT>MPI_ERRORS_RETURN</TT> may be used to cause error values to be returned.
|
||||
Note that MPI does <EM>not</EM> guarentee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL><DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_COMM </B> <DD> Invalid communicator. A common error is to use a null
|
||||
communicator in a call (not even allowed in <tt>MPI_Comm_rank</tt>).
|
||||
communicator in a call (not even allowed in <TT>MPI_Comm_rank</TT>).
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_COUNT </B> <DD> Invalid count argument. Count arguments must be
|
||||
non-negative; a count of zero is often valid.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_TYPE </B> <DD> Invalid datatype argument. Additionally, this error can
|
||||
occur if an uncommitted MPI_Datatype (see <tt>MPI_Type_commit</tt>) is used
|
||||
occur if an uncommitted MPI_Datatype (see <TT>MPI_Type_commit</TT>) is used
|
||||
in a communication call.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_BUFFER </B> <DD> Invalid buffer pointer. Usually a null buffer where
|
||||
|
||||
@@ -9,8 +9,7 @@
|
||||
Basic send with user-provided buffering
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
int MPI_Bsend(const void *buf, int count, MPI_Datatype datatype, int dest, int tag,
|
||||
MPI_Comm comm)
|
||||
int MPI_Bsend(const void *buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm)
|
||||
</PRE>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
@@ -30,32 +29,32 @@ int MPI_Bsend(const void *buf, int count, MPI_Datatype datatype, int dest, int t
|
||||
<H2>Notes</H2>
|
||||
This send is provided as a convenience function; it allows the user to
|
||||
send messages without worring about where they are buffered (because the
|
||||
user <em>must</em> have provided buffer space with <tt>MPI_Buffer_attach</tt>).
|
||||
user <EM>must</EM> have provided buffer space with <TT>MPI_Buffer_attach</TT>).
|
||||
<P>
|
||||
In deciding how much buffer space to allocate, remember that the buffer space
|
||||
is not available for reuse by subsequent <tt>MPI_Bsend</tt>s unless you are certain
|
||||
is not available for reuse by subsequent <TT>MPI_Bsend</TT>s unless you are certain
|
||||
that the message
|
||||
has been received (not just that it should have been received). For example,
|
||||
this code does not allocate enough buffer space
|
||||
<PRE>
|
||||
MPI_Buffer_attach( b, n*sizeof(double) + MPI_BSEND_OVERHEAD );
|
||||
MPI_Buffer_attach(b, n*sizeof(double) + MPI_BSEND_OVERHEAD);
|
||||
for (i=0; i<m; i++) {
|
||||
MPI_Bsend( buf, n, MPI_DOUBLE, ... );
|
||||
MPI_Bsend(buf, n, MPI_DOUBLE, ...);
|
||||
}
|
||||
</PRE>
|
||||
|
||||
because only enough buffer space is provided for a single send, and the
|
||||
loop may start a second <tt>MPI_Bsend</tt> before the first is done making use of the
|
||||
loop may start a second <TT>MPI_Bsend</TT> before the first is done making use of the
|
||||
buffer.
|
||||
<P>
|
||||
In C, you can
|
||||
force the messages to be delivered by
|
||||
<PRE>
|
||||
MPI_Buffer_detach( &b, &n );
|
||||
MPI_Buffer_attach( b, n );
|
||||
MPI_Buffer_detach(&b, &n);
|
||||
MPI_Buffer_attach(b, n);
|
||||
</PRE>
|
||||
|
||||
(The <tt>MPI_Buffer_detach</tt> will not complete until all buffered messages are
|
||||
(The <TT>MPI_Buffer_detach</TT> will not complete until all buffered messages are
|
||||
delivered.)
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
@@ -63,57 +62,57 @@ delivered.)
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
this is due to the use of memory allocation routines such as <TT>malloc
|
||||
</TT>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
All MPI routines in Fortran (except for <TT>MPI_WTIME</TT> and <TT>MPI_WTICK</TT>) have
|
||||
an additional argument <TT>ierr</TT> at the end of the argument list. <TT>ierr
|
||||
</TT>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<TT>call</TT> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
All MPI objects (e.g., <TT>MPI_Datatype</TT>, <TT>MPI_Comm</TT>) are of type <TT>INTEGER
|
||||
</TT>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
All MPI routines (except <TT>MPI_Wtime</TT> and <TT>MPI_Wtick</TT>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
may be changed with <TT>MPI_Comm_set_errhandler</TT> (for communicators),
|
||||
<TT>MPI_File_set_errhandler</TT> (for files), and <TT>MPI_Win_set_errhandler</TT> (for
|
||||
RMA windows). The MPI-1 routine <TT>MPI_Errhandler_set</TT> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarentee that an MPI program can continue past
|
||||
<TT>MPI_ERRORS_RETURN</TT> may be used to cause error values to be returned.
|
||||
Note that MPI does <EM>not</EM> guarentee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL><DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_COMM </B> <DD> Invalid communicator. A common error is to use a null
|
||||
communicator in a call (not even allowed in <tt>MPI_Comm_rank</tt>).
|
||||
communicator in a call (not even allowed in <TT>MPI_Comm_rank</TT>).
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_COUNT </B> <DD> Invalid count argument. Count arguments must be
|
||||
non-negative; a count of zero is often valid.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_TYPE </B> <DD> Invalid datatype argument. Additionally, this error can
|
||||
occur if an uncommitted MPI_Datatype (see <tt>MPI_Type_commit</tt>) is used
|
||||
occur if an uncommitted MPI_Datatype (see <TT>MPI_Type_commit</TT>) is used
|
||||
in a communication call.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_RANK </B> <DD> Invalid source or destination rank. Ranks must be between
|
||||
zero and the size of the communicator minus one; ranks in a receive
|
||||
(<tt>MPI_Recv</tt>, <tt>MPI_Irecv</tt>, <tt>MPI_Sendrecv</tt>, etc.) may also be <tt>MPI_ANY_SOURCE</tt>.
|
||||
(<TT>MPI_Recv</TT>, <TT>MPI_Irecv</TT>, <TT>MPI_Sendrecv</TT>, etc.) may also be <TT>MPI_ANY_SOURCE</TT>.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_TAG </B> <DD> Invalid tag argument. Tags must be non-negative; tags
|
||||
in a receive (<tt>MPI_Recv</tt>, <tt>MPI_Irecv</tt>, <tt>MPI_Sendrecv</tt>, etc.) may
|
||||
also be <tt>MPI_ANY_TAG</tt>. The largest tag value is available through the
|
||||
the attribute <tt>MPI_TAG_UB</tt>.
|
||||
in a receive (<TT>MPI_Recv</TT>, <TT>MPI_Irecv</TT>, <TT>MPI_Sendrecv</TT>, etc.) may
|
||||
also be <TT>MPI_ANY_TAG</TT>. The largest tag value is available through the
|
||||
the attribute <TT>MPI_TAG_UB</TT>.
|
||||
</DL>
|
||||
<P>
|
||||
<H0>See Also</H0>
|
||||
<H2>See Also</H2>
|
||||
MPI_Buffer_attach, MPI_Ibsend, MPI_Bsend_init
|
||||
<br>
|
||||
<BR>
|
||||
</BODY></HTML>
|
||||
|
||||
@@ -10,7 +10,7 @@ Builds a handle for a buffered send
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
int MPI_Bsend_init(const void *buf, int count, MPI_Datatype datatype,
|
||||
int dest, int tag, MPI_Comm comm, MPI_Request *request)
|
||||
int dest, int tag, MPI_Comm comm, MPI_Request * request)
|
||||
</PRE>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
@@ -36,57 +36,57 @@ int MPI_Bsend_init(const void *buf, int count, MPI_Datatype datatype,
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
this is due to the use of memory allocation routines such as <TT>malloc
|
||||
</TT>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
All MPI routines in Fortran (except for <TT>MPI_WTIME</TT> and <TT>MPI_WTICK</TT>) have
|
||||
an additional argument <TT>ierr</TT> at the end of the argument list. <TT>ierr
|
||||
</TT>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<TT>call</TT> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
All MPI objects (e.g., <TT>MPI_Datatype</TT>, <TT>MPI_Comm</TT>) are of type <TT>INTEGER
|
||||
</TT>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
All MPI routines (except <TT>MPI_Wtime</TT> and <TT>MPI_Wtick</TT>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
may be changed with <TT>MPI_Comm_set_errhandler</TT> (for communicators),
|
||||
<TT>MPI_File_set_errhandler</TT> (for files), and <TT>MPI_Win_set_errhandler</TT> (for
|
||||
RMA windows). The MPI-1 routine <TT>MPI_Errhandler_set</TT> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarentee that an MPI program can continue past
|
||||
<TT>MPI_ERRORS_RETURN</TT> may be used to cause error values to be returned.
|
||||
Note that MPI does <EM>not</EM> guarentee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL><DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_COMM </B> <DD> Invalid communicator. A common error is to use a null
|
||||
communicator in a call (not even allowed in <tt>MPI_Comm_rank</tt>).
|
||||
communicator in a call (not even allowed in <TT>MPI_Comm_rank</TT>).
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_COUNT </B> <DD> Invalid count argument. Count arguments must be
|
||||
non-negative; a count of zero is often valid.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_TYPE </B> <DD> Invalid datatype argument. Additionally, this error can
|
||||
occur if an uncommitted MPI_Datatype (see <tt>MPI_Type_commit</tt>) is used
|
||||
occur if an uncommitted MPI_Datatype (see <TT>MPI_Type_commit</TT>) is used
|
||||
in a communication call.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_RANK </B> <DD> Invalid source or destination rank. Ranks must be between
|
||||
zero and the size of the communicator minus one; ranks in a receive
|
||||
(<tt>MPI_Recv</tt>, <tt>MPI_Irecv</tt>, <tt>MPI_Sendrecv</tt>, etc.) may also be <tt>MPI_ANY_SOURCE</tt>.
|
||||
(<TT>MPI_Recv</TT>, <TT>MPI_Irecv</TT>, <TT>MPI_Sendrecv</TT>, etc.) may also be <TT>MPI_ANY_SOURCE</TT>.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_TAG </B> <DD> Invalid tag argument. Tags must be non-negative; tags
|
||||
in a receive (<tt>MPI_Recv</tt>, <tt>MPI_Irecv</tt>, <tt>MPI_Sendrecv</tt>, etc.) may
|
||||
also be <tt>MPI_ANY_TAG</tt>. The largest tag value is available through the
|
||||
the attribute <tt>MPI_TAG_UB</tt>.
|
||||
in a receive (<TT>MPI_Recv</TT>, <TT>MPI_Irecv</TT>, <TT>MPI_Sendrecv</TT>, etc.) may
|
||||
also be <TT>MPI_ANY_TAG</TT>. The largest tag value is available through the
|
||||
the attribute <TT>MPI_TAG_UB</TT>.
|
||||
</DL>
|
||||
<P>
|
||||
<H0>See Also</H0>
|
||||
<H2>See Also</H2>
|
||||
MPI_Buffer_attach
|
||||
<br>
|
||||
<BR>
|
||||
</BODY></HTML>
|
||||
|
||||
@@ -20,27 +20,27 @@ int MPI_Buffer_attach(void *buffer, int size)
|
||||
<P>
|
||||
<H2>Notes</H2>
|
||||
The size given should be the sum of the sizes of all outstanding Bsends that
|
||||
you intend to have, plus <tt>MPI_BSEND_OVERHEAD</tt> for each Bsend that you do.
|
||||
For the purposes of calculating size, you should use <tt>MPI_Pack_size</tt>.
|
||||
you intend to have, plus <TT>MPI_BSEND_OVERHEAD</TT> for each Bsend that you do.
|
||||
For the purposes of calculating size, you should use <TT>MPI_Pack_size</TT>.
|
||||
In other words, in the code
|
||||
<PRE>
|
||||
MPI_Buffer_attach( buffer, size );
|
||||
MPI_Bsend( ..., count=20, datatype=type1, ... );
|
||||
MPI_Buffer_attach(buffer, size);
|
||||
MPI_Bsend(..., count=20, datatype=type1, ...);
|
||||
...
|
||||
MPI_Bsend( ..., count=40, datatype=type2, ... );
|
||||
MPI_Bsend(..., count=40, datatype=type2, ...);
|
||||
</PRE>
|
||||
|
||||
the value of <tt>size</tt> in the <tt>MPI_Buffer_attach</tt> call should be greater than
|
||||
the value of <TT>size</TT> in the <TT>MPI_Buffer_attach</TT> call should be greater than
|
||||
the value computed by
|
||||
<PRE>
|
||||
MPI_Pack_size( 20, type1, comm, &s1 );
|
||||
MPI_Pack_size( 40, type2, comm, &s2 );
|
||||
MPI_Pack_size(20, type1, comm, &s1);
|
||||
MPI_Pack_size(40, type2, comm, &s2);
|
||||
size = s1 + s2 + 2 * MPI_BSEND_OVERHEAD;
|
||||
</PRE>
|
||||
|
||||
The <tt>MPI_BSEND_OVERHEAD</tt> gives the maximum amount of space that may be used in
|
||||
The <TT>MPI_BSEND_OVERHEAD</TT> gives the maximum amount of space that may be used in
|
||||
the buffer for use by the BSEND routines in using the buffer. This value
|
||||
is in <tt>mpi.h</tt> (for C) and <tt>mpif.h</tt> (for Fortran).
|
||||
is in <TT>mpi.h</TT> (for C) and <TT>mpif.h</TT> (for Fortran).
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
<P>
|
||||
@@ -51,35 +51,35 @@ not be used from within a signal handler.
|
||||
The MPI standard defined a thread-safe interface but this does not
|
||||
mean that all routines may be called without any thread locks. For
|
||||
example, two threads must not attempt to change the contents of the
|
||||
same <tt>MPI_Info</tt> object concurrently. The user is responsible in this
|
||||
same <TT>MPI_Info</TT> object concurrently. The user is responsible in this
|
||||
case for using some mechanism, such as thread locks, to ensure that
|
||||
only one thread at a time makes use of this routine.
|
||||
Because the buffer for buffered sends (e.g., <tt>MPI_Bsend</tt>) is shared by all
|
||||
Because the buffer for buffered sends (e.g., <TT>MPI_Bsend</TT>) is shared by all
|
||||
threads in a process, the user is responsible for ensuring that only
|
||||
one thread at a time calls this routine or <tt>MPI_Buffer_detach</tt>.
|
||||
one thread at a time calls this routine or <TT>MPI_Buffer_detach</TT>.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
All MPI routines in Fortran (except for <TT>MPI_WTIME</TT> and <TT>MPI_WTICK</TT>) have
|
||||
an additional argument <TT>ierr</TT> at the end of the argument list. <TT>ierr
|
||||
</TT>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<TT>call</TT> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
All MPI objects (e.g., <TT>MPI_Datatype</TT>, <TT>MPI_Comm</TT>) are of type <TT>INTEGER
|
||||
</TT>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
All MPI routines (except <TT>MPI_Wtime</TT> and <TT>MPI_Wtick</TT>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
may be changed with <TT>MPI_Comm_set_errhandler</TT> (for communicators),
|
||||
<TT>MPI_File_set_errhandler</TT> (for files), and <TT>MPI_Win_set_errhandler</TT> (for
|
||||
RMA windows). The MPI-1 routine <TT>MPI_Errhandler_set</TT> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarentee that an MPI program can continue past
|
||||
<TT>MPI_ERRORS_RETURN</TT> may be used to cause error values to be returned.
|
||||
Note that MPI does <EM>not</EM> guarentee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
@@ -89,10 +89,10 @@ possible.
|
||||
one is not valid.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_INTERN </B> <DD> An internal error has been detected. This is fatal.
|
||||
Please send a bug report to <tt>mpi-bugs@mcs.anl.gov</tt>.
|
||||
Please send a bug report to <TT>mpi-bugs@mcs.anl.gov</TT>.
|
||||
</DL>
|
||||
<P>
|
||||
<H0>See Also</H0>
|
||||
<H2>See Also</H2>
|
||||
MPI_Buffer_detach, MPI_Bsend
|
||||
<br>
|
||||
<BR>
|
||||
</BODY></HTML>
|
||||
|
||||
@@ -19,20 +19,20 @@ int MPI_Buffer_detach(void *buffer_addr, int *size)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Notes</H2>
|
||||
The reason that <tt>MPI_Buffer_detach</tt> returns the address and size of the
|
||||
The reason that <TT>MPI_Buffer_detach</TT> returns the address and size of the
|
||||
buffer being detached is to allow nested libraries to replace and restore
|
||||
the buffer. For example, consider
|
||||
<P>
|
||||
<PRE>
|
||||
int size, mysize, idummy;
|
||||
void *ptr, *myptr, *dummy;
|
||||
MPI_Buffer_detach( &ptr, &size );
|
||||
MPI_Buffer_attach( myptr, mysize );
|
||||
MPI_Buffer_detach(&ptr, &size);
|
||||
MPI_Buffer_attach(myptr, mysize);
|
||||
...
|
||||
... library code ...
|
||||
...
|
||||
MPI_Buffer_detach( &dummy, &idummy );
|
||||
MPI_Buffer_attach( ptr, size );
|
||||
MPI_Buffer_detach(&dummy, &idummy);
|
||||
MPI_Buffer_attach(ptr, size);
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
@@ -41,7 +41,7 @@ strengths (it is simple) and weaknesses (it only works for nested usages).
|
||||
<P>
|
||||
Note that for this approach to work, MPI_Buffer_detach must return MPI_SUCCESS
|
||||
even when there is no buffer to detach. In that case, it returns a size of
|
||||
zero. The MPI 1.1 standard for <tt>MPI_BUFFER_DETACH</tt> contains the text
|
||||
zero. The MPI 1.1 standard for <TT>MPI_BUFFER_DETACH</TT> contains the text
|
||||
<P>
|
||||
<PRE>
|
||||
The statements made in this section describe the behavior of MPI for
|
||||
@@ -51,8 +51,8 @@ zero. The MPI 1.1 standard for <tt>MPI_BUFFER_DETACH</tt> contains the text
|
||||
|
||||
<P>
|
||||
This could be read as applying only to the various Bsend routines. This
|
||||
implementation takes the position that this applies to <tt>MPI_BUFFER_DETACH
|
||||
</tt>as well.
|
||||
implementation takes the position that this applies to <TT>MPI_BUFFER_DETACH
|
||||
</TT>as well.
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
<P>
|
||||
@@ -63,22 +63,22 @@ not be used from within a signal handler.
|
||||
The MPI standard defined a thread-safe interface but this does not
|
||||
mean that all routines may be called without any thread locks. For
|
||||
example, two threads must not attempt to change the contents of the
|
||||
same <tt>MPI_Info</tt> object concurrently. The user is responsible in this
|
||||
same <TT>MPI_Info</TT> object concurrently. The user is responsible in this
|
||||
case for using some mechanism, such as thread locks, to ensure that
|
||||
only one thread at a time makes use of this routine.
|
||||
Because the buffer for buffered sends (e.g., <tt>MPI_Bsend</tt>) is shared by all
|
||||
Because the buffer for buffered sends (e.g., <TT>MPI_Bsend</TT>) is shared by all
|
||||
threads in a process, the user is responsible for ensuring that only
|
||||
one thread at a time calls this routine or <tt>MPI_Buffer_attach</tt>.
|
||||
one thread at a time calls this routine or <TT>MPI_Buffer_attach</TT>.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
All MPI routines in Fortran (except for <TT>MPI_WTIME</TT> and <TT>MPI_WTICK</TT>) have
|
||||
an additional argument <TT>ierr</TT> at the end of the argument list. <TT>ierr
|
||||
</TT>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<TT>call</TT> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
All MPI objects (e.g., <TT>MPI_Datatype</TT>, <TT>MPI_Comm</TT>) are of type <TT>INTEGER
|
||||
</TT>in Fortran.
|
||||
<P>
|
||||
The Fortran binding for this routine is different. Because Fortran
|
||||
does not have pointers, it is impossible to provide a way to use the
|
||||
@@ -86,11 +86,11 @@ output of this routine to exchange buffers. In this case, only the
|
||||
size field is set.
|
||||
<P>
|
||||
<H2>Notes for C</H2>
|
||||
Even though the <tt>bufferptr</tt> argument is declared as <tt>void *</tt>, it is
|
||||
Even though the <TT>bufferptr</TT> argument is declared as <TT>void *</TT>, it is
|
||||
really the address of a void pointer. See the rationale in the
|
||||
standard for more details.
|
||||
<P>
|
||||
<H0>See Also</H0>
|
||||
<H2>See Also</H2>
|
||||
MPI_Buffer_attach
|
||||
<br>
|
||||
<BR>
|
||||
</BODY></HTML>
|
||||
|
||||
@@ -9,16 +9,16 @@
|
||||
Cancels a communication request
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
int MPI_Cancel(MPI_Request *request)
|
||||
int MPI_Cancel(MPI_Request * request)
|
||||
</PRE>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL><DT><B>request </B> <DD> communication request (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Notes</H2>
|
||||
The primary expected use of <tt>MPI_Cancel</tt> is in multi-buffering
|
||||
schemes, where speculative <tt>MPI_Irecvs</tt> are made. When the computation
|
||||
completes, some of these receive requests may remain; using <tt>MPI_Cancel</tt> allows
|
||||
The primary expected use of <TT>MPI_Cancel</TT> is in multi-buffering
|
||||
schemes, where speculative <TT>MPI_Irecvs</TT> are made. When the computation
|
||||
completes, some of these receive requests may remain; using <TT>MPI_Cancel</TT> allows
|
||||
the user to cancel these unsatisfied requests.
|
||||
<P>
|
||||
Cancelling a send operation is much more difficult, in large part because the
|
||||
@@ -34,18 +34,18 @@ messages).
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
this is due to the use of memory allocation routines such as <TT>malloc
|
||||
</TT>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
All MPI routines in Fortran (except for <TT>MPI_WTIME</TT> and <TT>MPI_WTICK</TT>) have
|
||||
an additional argument <TT>ierr</TT> at the end of the argument list. <TT>ierr
|
||||
</TT>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<TT>call</TT> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
All MPI objects (e.g., <TT>MPI_Datatype</TT>, <TT>MPI_Comm</TT>) are of type <TT>INTEGER
|
||||
</TT>in Fortran.
|
||||
<P>
|
||||
<H2>Null Handles</H2>
|
||||
The MPI 1.1 specification, in the section on opaque objects, explicitly
|
||||
@@ -62,25 +62,25 @@ disallows freeing a null communicator. The text from the standard is:
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
All MPI routines (except <TT>MPI_Wtime</TT> and <TT>MPI_Wtick</TT>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
may be changed with <TT>MPI_Comm_set_errhandler</TT> (for communicators),
|
||||
<TT>MPI_File_set_errhandler</TT> (for files), and <TT>MPI_Win_set_errhandler</TT> (for
|
||||
RMA windows). The MPI-1 routine <TT>MPI_Errhandler_set</TT> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarentee that an MPI program can continue past
|
||||
<TT>MPI_ERRORS_RETURN</TT> may be used to cause error values to be returned.
|
||||
Note that MPI does <EM>not</EM> guarentee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL><DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_REQUEST </B> <DD> Invalid <tt>MPI_Request</tt>. Either null or, in the case of a
|
||||
<tt>MPI_Start</tt> or <tt>MPI_Startall</tt>, not a persistent request.
|
||||
<DL><DT><B>MPI_ERR_REQUEST </B> <DD> Invalid <TT>MPI_Request</TT>. Either null or, in the case of a
|
||||
<TT>MPI_Start</TT> or <TT>MPI_Startall</TT>, not a persistent request.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_ARG </B> <DD> Invalid argument. Some argument is invalid and is not
|
||||
identified by a specific error class (e.g., <tt>MPI_ERR_RANK</tt>).
|
||||
identified by a specific error class (e.g., <TT>MPI_ERR_RANK</TT>).
|
||||
</DL>
|
||||
</BODY></HTML>
|
||||
|
||||
@@ -15,13 +15,13 @@ int MPI_Cart_coords(MPI_Comm comm, int rank, int maxdims, int coords[])
|
||||
<DL>
|
||||
<DT><B>comm </B><DD>communicator with cartesian structure (handle)
|
||||
|
||||
<DT><B>rank </B><DD>rank of a process within group of <tt>comm</tt> (integer)
|
||||
<DT><B>rank </B><DD>rank of a process within group of <TT>comm</TT> (integer)
|
||||
|
||||
<DT><B>maxdims </B><DD>length of vector <tt>coords</tt> in the calling program (integer)
|
||||
<DT><B>maxdims </B><DD>length of vector <TT>coords</TT> in the calling program (integer)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL><DT><B>coords </B> <DD> integer array (of size <tt>ndims</tt>) containing the Cartesian
|
||||
<DL><DT><B>coords </B> <DD> integer array (of size <TT>ndims</TT>) containing the Cartesian
|
||||
coordinates of specified process (integer)
|
||||
</DL>
|
||||
<P>
|
||||
@@ -32,27 +32,27 @@ This means that this routine may safely be used by multiple threads and
|
||||
from within a signal handler.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
All MPI routines in Fortran (except for <TT>MPI_WTIME</TT> and <TT>MPI_WTICK</TT>) have
|
||||
an additional argument <TT>ierr</TT> at the end of the argument list. <TT>ierr
|
||||
</TT>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<TT>call</TT> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
All MPI objects (e.g., <TT>MPI_Datatype</TT>, <TT>MPI_Comm</TT>) are of type <TT>INTEGER
|
||||
</TT>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
All MPI routines (except <TT>MPI_Wtime</TT> and <TT>MPI_Wtick</TT>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
may be changed with <TT>MPI_Comm_set_errhandler</TT> (for communicators),
|
||||
<TT>MPI_File_set_errhandler</TT> (for files), and <TT>MPI_Win_set_errhandler</TT> (for
|
||||
RMA windows). The MPI-1 routine <TT>MPI_Errhandler_set</TT> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarentee that an MPI program can continue past
|
||||
<TT>MPI_ERRORS_RETURN</TT> may be used to cause error values to be returned.
|
||||
Note that MPI does <EM>not</EM> guarentee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
@@ -60,16 +60,16 @@ possible.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_TOPOLOGY </B> <DD> Invalid topology. Either there is no topology
|
||||
associated with this communicator, or it is not the correct type (e.g.,
|
||||
<tt>MPI_CART</tt> when expecting <tt>MPI_GRAPH</tt>).
|
||||
<TT>MPI_CART</TT> when expecting <TT>MPI_GRAPH</TT>).
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_RANK </B> <DD> Invalid source or destination rank. Ranks must be between
|
||||
zero and the size of the communicator minus one; ranks in a receive
|
||||
(<tt>MPI_Recv</tt>, <tt>MPI_Irecv</tt>, <tt>MPI_Sendrecv</tt>, etc.) may also be <tt>MPI_ANY_SOURCE</tt>.
|
||||
(<TT>MPI_Recv</TT>, <TT>MPI_Irecv</TT>, <TT>MPI_Sendrecv</TT>, etc.) may also be <TT>MPI_ANY_SOURCE</TT>.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_DIMS </B> <DD> Invalid dimension argument. A dimension argument
|
||||
is null or its length is less than or equal to zero.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_ARG </B> <DD> Invalid argument. Some argument is invalid and is not
|
||||
identified by a specific error class (e.g., <tt>MPI_ERR_RANK</tt>).
|
||||
identified by a specific error class (e.g., <TT>MPI_ERR_RANK</TT>).
|
||||
</DL>
|
||||
</BODY></HTML>
|
||||
|
||||
@@ -10,7 +10,7 @@ Makes a new communicator to which topology information has been attached
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
int MPI_Cart_create(MPI_Comm comm_old, int ndims, const int dims[],
|
||||
const int periods[], int reorder, MPI_Comm *comm_cart)
|
||||
const int periods[], int reorder, MPI_Comm * comm_cart)
|
||||
</PRE>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
@@ -32,38 +32,38 @@ periodic (true) or not (false) in each dimension
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Algorithm</H2>
|
||||
We ignore <tt>reorder</tt> info currently.
|
||||
We ignore <TT>reorder</TT> info currently.
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
<P>
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
this is due to the use of memory allocation routines such as <TT>malloc
|
||||
</TT>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
All MPI routines in Fortran (except for <TT>MPI_WTIME</TT> and <TT>MPI_WTICK</TT>) have
|
||||
an additional argument <TT>ierr</TT> at the end of the argument list. <TT>ierr
|
||||
</TT>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<TT>call</TT> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
All MPI objects (e.g., <TT>MPI_Datatype</TT>, <TT>MPI_Comm</TT>) are of type <TT>INTEGER
|
||||
</TT>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
All MPI routines (except <TT>MPI_Wtime</TT> and <TT>MPI_Wtick</TT>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
may be changed with <TT>MPI_Comm_set_errhandler</TT> (for communicators),
|
||||
<TT>MPI_File_set_errhandler</TT> (for files), and <TT>MPI_Win_set_errhandler</TT> (for
|
||||
RMA windows). The MPI-1 routine <TT>MPI_Errhandler_set</TT> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarentee that an MPI program can continue past
|
||||
<TT>MPI_ERRORS_RETURN</TT> may be used to cause error values to be returned.
|
||||
Note that MPI does <EM>not</EM> guarentee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
@@ -71,12 +71,12 @@ possible.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_TOPOLOGY </B> <DD> Invalid topology. Either there is no topology
|
||||
associated with this communicator, or it is not the correct type (e.g.,
|
||||
<tt>MPI_CART</tt> when expecting <tt>MPI_GRAPH</tt>).
|
||||
<TT>MPI_CART</TT> when expecting <TT>MPI_GRAPH</TT>).
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_DIMS </B> <DD> Invalid dimension argument. A dimension argument
|
||||
is null or its length is less than or equal to zero.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_ARG </B> <DD> Invalid argument. Some argument is invalid and is not
|
||||
identified by a specific error class (e.g., <tt>MPI_ERR_RANK</tt>).
|
||||
identified by a specific error class (e.g., <TT>MPI_ERR_RANK</TT>).
|
||||
</DL>
|
||||
</BODY></HTML>
|
||||
|
||||
@@ -9,15 +9,14 @@
|
||||
Retrieves Cartesian topology information associated with a communicator
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
int MPI_Cart_get(MPI_Comm comm, int maxdims, int dims[], int periods[],
|
||||
int coords[])
|
||||
int MPI_Cart_get(MPI_Comm comm, int maxdims, int dims[], int periods[], int coords[])
|
||||
</PRE>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>comm </B><DD>communicator with cartesian structure (handle)
|
||||
|
||||
<DT><B>maxdims </B><DD>length of vectors <tt>dims</tt>, <tt>periods</tt>, and <tt>coords
|
||||
</tt>in the calling program (integer)
|
||||
<DT><B>maxdims </B><DD>length of vectors <TT>dims</TT>, <TT>periods</TT>, and <TT>coords
|
||||
</TT>in the calling program (integer)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
@@ -36,31 +35,31 @@ int MPI_Cart_get(MPI_Comm comm, int maxdims, int dims[], int periods[],
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
this is due to the use of memory allocation routines such as <TT>malloc
|
||||
</TT>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
All MPI routines in Fortran (except for <TT>MPI_WTIME</TT> and <TT>MPI_WTICK</TT>) have
|
||||
an additional argument <TT>ierr</TT> at the end of the argument list. <TT>ierr
|
||||
</TT>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<TT>call</TT> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
All MPI objects (e.g., <TT>MPI_Datatype</TT>, <TT>MPI_Comm</TT>) are of type <TT>INTEGER
|
||||
</TT>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
All MPI routines (except <TT>MPI_Wtime</TT> and <TT>MPI_Wtick</TT>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
may be changed with <TT>MPI_Comm_set_errhandler</TT> (for communicators),
|
||||
<TT>MPI_File_set_errhandler</TT> (for files), and <TT>MPI_Win_set_errhandler</TT> (for
|
||||
RMA windows). The MPI-1 routine <TT>MPI_Errhandler_set</TT> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarentee that an MPI program can continue past
|
||||
<TT>MPI_ERRORS_RETURN</TT> may be used to cause error values to be returned.
|
||||
Note that MPI does <EM>not</EM> guarentee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
@@ -68,12 +67,12 @@ possible.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_TOPOLOGY </B> <DD> Invalid topology. Either there is no topology
|
||||
associated with this communicator, or it is not the correct type (e.g.,
|
||||
<tt>MPI_CART</tt> when expecting <tt>MPI_GRAPH</tt>).
|
||||
<TT>MPI_CART</TT> when expecting <TT>MPI_GRAPH</TT>).
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_COMM </B> <DD> Invalid communicator. A common error is to use a null
|
||||
communicator in a call (not even allowed in <tt>MPI_Comm_rank</tt>).
|
||||
communicator in a call (not even allowed in <TT>MPI_Comm_rank</TT>).
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_ARG </B> <DD> Invalid argument. Some argument is invalid and is not
|
||||
identified by a specific error class (e.g., <tt>MPI_ERR_RANK</tt>).
|
||||
identified by a specific error class (e.g., <TT>MPI_ERR_RANK</TT>).
|
||||
</DL>
|
||||
</BODY></HTML>
|
||||
|
||||
@@ -9,8 +9,7 @@
|
||||
Maps process to Cartesian topology information
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
int MPI_Cart_map(MPI_Comm comm, int ndims, const int dims[], const int periods[],
|
||||
int *newrank)
|
||||
int MPI_Cart_map(MPI_Comm comm, int ndims, const int dims[], const int periods[], int *newrank)
|
||||
</PRE>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
@@ -18,15 +17,15 @@ int MPI_Cart_map(MPI_Comm comm, int ndims, const int dims[], const int periods[]
|
||||
|
||||
<DT><B>ndims </B><DD>number of dimensions of Cartesian structure (integer)
|
||||
|
||||
<DT><B>dims </B><DD>integer array of size <tt>ndims</tt> specifying the number of processes in
|
||||
<DT><B>dims </B><DD>integer array of size <TT>ndims</TT> specifying the number of processes in
|
||||
each coordinate direction
|
||||
|
||||
<DT><B>periods </B><DD>logical array of size <tt>ndims</tt> specifying the periodicity
|
||||
<DT><B>periods </B><DD>logical array of size <TT>ndims</TT> specifying the periodicity
|
||||
specification in each coordinate direction
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL><DT><B>newrank </B> <DD> reordered rank of the calling process; <tt>MPI_UNDEFINED</tt> if
|
||||
<DL><DT><B>newrank </B> <DD> reordered rank of the calling process; <TT>MPI_UNDEFINED</TT> if
|
||||
calling process does not belong to grid (integer)
|
||||
</DL>
|
||||
<P>
|
||||
@@ -37,39 +36,39 @@ This means that this routine may safely be used by multiple threads and
|
||||
from within a signal handler.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
All MPI routines in Fortran (except for <TT>MPI_WTIME</TT> and <TT>MPI_WTICK</TT>) have
|
||||
an additional argument <TT>ierr</TT> at the end of the argument list. <TT>ierr
|
||||
</TT>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<TT>call</TT> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
All MPI objects (e.g., <TT>MPI_Datatype</TT>, <TT>MPI_Comm</TT>) are of type <TT>INTEGER
|
||||
</TT>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
All MPI routines (except <TT>MPI_Wtime</TT> and <TT>MPI_Wtick</TT>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
may be changed with <TT>MPI_Comm_set_errhandler</TT> (for communicators),
|
||||
<TT>MPI_File_set_errhandler</TT> (for files), and <TT>MPI_Win_set_errhandler</TT> (for
|
||||
RMA windows). The MPI-1 routine <TT>MPI_Errhandler_set</TT> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarentee that an MPI program can continue past
|
||||
<TT>MPI_ERRORS_RETURN</TT> may be used to cause error values to be returned.
|
||||
Note that MPI does <EM>not</EM> guarentee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL><DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_COMM </B> <DD> Invalid communicator. A common error is to use a null
|
||||
communicator in a call (not even allowed in <tt>MPI_Comm_rank</tt>).
|
||||
communicator in a call (not even allowed in <TT>MPI_Comm_rank</TT>).
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_DIMS </B> <DD> Invalid dimension argument. A dimension argument
|
||||
is null or its length is less than or equal to zero.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_ARG </B> <DD> Invalid argument. Some argument is invalid and is not
|
||||
identified by a specific error class (e.g., <tt>MPI_ERR_RANK</tt>).
|
||||
identified by a specific error class (e.g., <TT>MPI_ERR_RANK</TT>).
|
||||
</DL>
|
||||
</BODY></HTML>
|
||||
|
||||
@@ -15,8 +15,8 @@ int MPI_Cart_rank(MPI_Comm comm, const int coords[], int *rank)
|
||||
<DL>
|
||||
<DT><B>comm </B><DD>communicator with cartesian structure (handle)
|
||||
|
||||
<DT><B>coords </B><DD>integer array (of size <tt>ndims</tt>, the number of dimensions of
|
||||
the Cartesian topology associated with <tt>comm</tt>) specifying the cartesian
|
||||
<DT><B>coords </B><DD>integer array (of size <TT>ndims</TT>, the number of dimensions of
|
||||
the Cartesian topology associated with <TT>comm</TT>) specifying the cartesian
|
||||
coordinates of a process
|
||||
</DL>
|
||||
<P>
|
||||
@@ -26,7 +26,7 @@ coordinates of a process
|
||||
<P>
|
||||
<H2>Notes</H2>
|
||||
Out-of-range coordinates are erroneous for non-periodic dimensions.
|
||||
Versions of MPICH before 1.2.2 returned <tt>MPI_PROC_NULL</tt> for the rank in this
|
||||
Versions of MPICH before 1.2.2 returned <TT>MPI_PROC_NULL</TT> for the rank in this
|
||||
case.
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
@@ -36,27 +36,27 @@ This means that this routine may safely be used by multiple threads and
|
||||
from within a signal handler.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
All MPI routines in Fortran (except for <TT>MPI_WTIME</TT> and <TT>MPI_WTICK</TT>) have
|
||||
an additional argument <TT>ierr</TT> at the end of the argument list. <TT>ierr
|
||||
</TT>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<TT>call</TT> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
All MPI objects (e.g., <TT>MPI_Datatype</TT>, <TT>MPI_Comm</TT>) are of type <TT>INTEGER
|
||||
</TT>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
All MPI routines (except <TT>MPI_Wtime</TT> and <TT>MPI_Wtick</TT>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
may be changed with <TT>MPI_Comm_set_errhandler</TT> (for communicators),
|
||||
<TT>MPI_File_set_errhandler</TT> (for files), and <TT>MPI_Win_set_errhandler</TT> (for
|
||||
RMA windows). The MPI-1 routine <TT>MPI_Errhandler_set</TT> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarentee that an MPI program can continue past
|
||||
<TT>MPI_ERRORS_RETURN</TT> may be used to cause error values to be returned.
|
||||
Note that MPI does <EM>not</EM> guarentee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
@@ -64,13 +64,13 @@ possible.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_TOPOLOGY </B> <DD> Invalid topology. Either there is no topology
|
||||
associated with this communicator, or it is not the correct type (e.g.,
|
||||
<tt>MPI_CART</tt> when expecting <tt>MPI_GRAPH</tt>).
|
||||
<TT>MPI_CART</TT> when expecting <TT>MPI_GRAPH</TT>).
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_RANK </B> <DD> Invalid source or destination rank. Ranks must be between
|
||||
zero and the size of the communicator minus one; ranks in a receive
|
||||
(<tt>MPI_Recv</tt>, <tt>MPI_Irecv</tt>, <tt>MPI_Sendrecv</tt>, etc.) may also be <tt>MPI_ANY_SOURCE</tt>.
|
||||
(<TT>MPI_Recv</TT>, <TT>MPI_Irecv</TT>, <TT>MPI_Sendrecv</TT>, etc.) may also be <TT>MPI_ANY_SOURCE</TT>.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_ARG </B> <DD> Invalid argument. Some argument is invalid and is not
|
||||
identified by a specific error class (e.g., <tt>MPI_ERR_RANK</tt>).
|
||||
identified by a specific error class (e.g., <TT>MPI_ERR_RANK</TT>).
|
||||
</DL>
|
||||
</BODY></HTML>
|
||||
|
||||
@@ -9,8 +9,7 @@
|
||||
Returns the shifted source and destination ranks, given a shift direction and amount
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
int MPI_Cart_shift(MPI_Comm comm, int direction, int disp, int *rank_source,
|
||||
int *rank_dest)
|
||||
int MPI_Cart_shift(MPI_Comm comm, int direction, int disp, int *rank_source, int *rank_dest)
|
||||
</PRE>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
@@ -29,7 +28,7 @@ int MPI_Cart_shift(MPI_Comm comm, int direction, int disp, int *rank_source,
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Notes</H2>
|
||||
The <tt>direction</tt> argument is in the range <tt>[0,n-1]</tt> for an n-dimensional
|
||||
The <TT>direction</TT> argument is in the range <TT>[0,n-1]</TT> for an n-dimensional
|
||||
Cartesian mesh.
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
@@ -39,27 +38,27 @@ This means that this routine may safely be used by multiple threads and
|
||||
from within a signal handler.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
All MPI routines in Fortran (except for <TT>MPI_WTIME</TT> and <TT>MPI_WTICK</TT>) have
|
||||
an additional argument <TT>ierr</TT> at the end of the argument list. <TT>ierr
|
||||
</TT>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<TT>call</TT> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
All MPI objects (e.g., <TT>MPI_Datatype</TT>, <TT>MPI_Comm</TT>) are of type <TT>INTEGER
|
||||
</TT>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
All MPI routines (except <TT>MPI_Wtime</TT> and <TT>MPI_Wtick</TT>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
may be changed with <TT>MPI_Comm_set_errhandler</TT> (for communicators),
|
||||
<TT>MPI_File_set_errhandler</TT> (for files), and <TT>MPI_Win_set_errhandler</TT> (for
|
||||
RMA windows). The MPI-1 routine <TT>MPI_Errhandler_set</TT> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarentee that an MPI program can continue past
|
||||
<TT>MPI_ERRORS_RETURN</TT> may be used to cause error values to be returned.
|
||||
Note that MPI does <EM>not</EM> guarentee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
@@ -67,12 +66,12 @@ possible.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_TOPOLOGY </B> <DD> Invalid topology. Either there is no topology
|
||||
associated with this communicator, or it is not the correct type (e.g.,
|
||||
<tt>MPI_CART</tt> when expecting <tt>MPI_GRAPH</tt>).
|
||||
<TT>MPI_CART</TT> when expecting <TT>MPI_GRAPH</TT>).
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_COMM </B> <DD> Invalid communicator. A common error is to use a null
|
||||
communicator in a call (not even allowed in <tt>MPI_Comm_rank</tt>).
|
||||
communicator in a call (not even allowed in <TT>MPI_Comm_rank</TT>).
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_ARG </B> <DD> Invalid argument. Some argument is invalid and is not
|
||||
identified by a specific error class (e.g., <tt>MPI_ERR_RANK</tt>).
|
||||
identified by a specific error class (e.g., <TT>MPI_ERR_RANK</TT>).
|
||||
</DL>
|
||||
</BODY></HTML>
|
||||
|
||||
@@ -9,13 +9,13 @@
|
||||
Partitions a communicator into subgroups which form lower-dimensional cartesian subgrids
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
int MPI_Cart_sub(MPI_Comm comm, const int remain_dims[], MPI_Comm *newcomm)
|
||||
int MPI_Cart_sub(MPI_Comm comm, const int remain_dims[], MPI_Comm * newcomm)
|
||||
</PRE>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>comm </B><DD>communicator with cartesian structure (handle)
|
||||
|
||||
<DT><B>remain_dims </B><DD>the <tt>i</tt>th entry of remain_dims specifies whether the <tt>i</tt>th
|
||||
<DT><B>remain_dims </B><DD>the <TT>i</TT>th entry of remain_dims specifies whether the <TT>i</TT>th
|
||||
dimension is kept in the subgrid (true) or is dropped (false) (logical
|
||||
vector)
|
||||
</DL>
|
||||
@@ -30,31 +30,31 @@ process (handle)
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
this is due to the use of memory allocation routines such as <TT>malloc
|
||||
</TT>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
All MPI routines in Fortran (except for <TT>MPI_WTIME</TT> and <TT>MPI_WTICK</TT>) have
|
||||
an additional argument <TT>ierr</TT> at the end of the argument list. <TT>ierr
|
||||
</TT>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<TT>call</TT> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
All MPI objects (e.g., <TT>MPI_Datatype</TT>, <TT>MPI_Comm</TT>) are of type <TT>INTEGER
|
||||
</TT>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
All MPI routines (except <TT>MPI_Wtime</TT> and <TT>MPI_Wtick</TT>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
may be changed with <TT>MPI_Comm_set_errhandler</TT> (for communicators),
|
||||
<TT>MPI_File_set_errhandler</TT> (for files), and <TT>MPI_Win_set_errhandler</TT> (for
|
||||
RMA windows). The MPI-1 routine <TT>MPI_Errhandler_set</TT> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarentee that an MPI program can continue past
|
||||
<TT>MPI_ERRORS_RETURN</TT> may be used to cause error values to be returned.
|
||||
Note that MPI does <EM>not</EM> guarentee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
@@ -62,12 +62,12 @@ possible.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_TOPOLOGY </B> <DD> Invalid topology. Either there is no topology
|
||||
associated with this communicator, or it is not the correct type (e.g.,
|
||||
<tt>MPI_CART</tt> when expecting <tt>MPI_GRAPH</tt>).
|
||||
<TT>MPI_CART</TT> when expecting <TT>MPI_GRAPH</TT>).
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_COMM </B> <DD> Invalid communicator. A common error is to use a null
|
||||
communicator in a call (not even allowed in <tt>MPI_Comm_rank</tt>).
|
||||
communicator in a call (not even allowed in <TT>MPI_Comm_rank</TT>).
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_ARG </B> <DD> Invalid argument. Some argument is invalid and is not
|
||||
identified by a specific error class (e.g., <tt>MPI_ERR_RANK</tt>).
|
||||
identified by a specific error class (e.g., <TT>MPI_ERR_RANK</TT>).
|
||||
</DL>
|
||||
</BODY></HTML>
|
||||
|
||||
@@ -26,36 +26,36 @@ This means that this routine may safely be used by multiple threads and
|
||||
from within a signal handler.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
All MPI routines in Fortran (except for <TT>MPI_WTIME</TT> and <TT>MPI_WTICK</TT>) have
|
||||
an additional argument <TT>ierr</TT> at the end of the argument list. <TT>ierr
|
||||
</TT>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<TT>call</TT> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
All MPI objects (e.g., <TT>MPI_Datatype</TT>, <TT>MPI_Comm</TT>) are of type <TT>INTEGER
|
||||
</TT>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
All MPI routines (except <TT>MPI_Wtime</TT> and <TT>MPI_Wtick</TT>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
may be changed with <TT>MPI_Comm_set_errhandler</TT> (for communicators),
|
||||
<TT>MPI_File_set_errhandler</TT> (for files), and <TT>MPI_Win_set_errhandler</TT> (for
|
||||
RMA windows). The MPI-1 routine <TT>MPI_Errhandler_set</TT> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarentee that an MPI program can continue past
|
||||
<TT>MPI_ERRORS_RETURN</TT> may be used to cause error values to be returned.
|
||||
Note that MPI does <EM>not</EM> guarentee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL><DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_COMM </B> <DD> Invalid communicator. A common error is to use a null
|
||||
communicator in a call (not even allowed in <tt>MPI_Comm_rank</tt>).
|
||||
communicator in a call (not even allowed in <TT>MPI_Comm_rank</TT>).
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_ARG </B> <DD> Invalid argument. Some argument is invalid and is not
|
||||
identified by a specific error class (e.g., <tt>MPI_ERR_RANK</tt>).
|
||||
identified by a specific error class (e.g., <TT>MPI_ERR_RANK</TT>).
|
||||
</DL>
|
||||
</BODY></HTML>
|
||||
|
||||
@@ -24,32 +24,32 @@ not be used from within a signal handler.
|
||||
The MPI standard defined a thread-safe interface but this does not
|
||||
mean that all routines may be called without any thread locks. For
|
||||
example, two threads must not attempt to change the contents of the
|
||||
same <tt>MPI_Info</tt> object concurrently. The user is responsible in this
|
||||
same <TT>MPI_Info</TT> object concurrently. The user is responsible in this
|
||||
case for using some mechanism, such as thread locks, to ensure that
|
||||
only one thread at a time makes use of this routine.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
All MPI routines in Fortran (except for <TT>MPI_WTIME</TT> and <TT>MPI_WTICK</TT>) have
|
||||
an additional argument <TT>ierr</TT> at the end of the argument list. <TT>ierr
|
||||
</TT>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<TT>call</TT> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
All MPI objects (e.g., <TT>MPI_Datatype</TT>, <TT>MPI_Comm</TT>) are of type <TT>INTEGER
|
||||
</TT>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
All MPI routines (except <TT>MPI_Wtime</TT> and <TT>MPI_Wtick</TT>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
may be changed with <TT>MPI_Comm_set_errhandler</TT> (for communicators),
|
||||
<TT>MPI_File_set_errhandler</TT> (for files), and <TT>MPI_Win_set_errhandler</TT> (for
|
||||
RMA windows). The MPI-1 routine <TT>MPI_Errhandler_set</TT> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarentee that an MPI program can continue past
|
||||
<TT>MPI_ERRORS_RETURN</TT> may be used to cause error values to be returned.
|
||||
Note that MPI does <EM>not</EM> guarentee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
|
||||
@@ -10,7 +10,7 @@ Accept a request to form a new intercommunicator
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
int MPI_Comm_accept(const char *port_name, MPI_Info info, int root, MPI_Comm comm,
|
||||
MPI_Comm *newcomm)
|
||||
MPI_Comm * newcomm)
|
||||
</PRE>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
@@ -32,31 +32,31 @@ int MPI_Comm_accept(const char *port_name, MPI_Info info, int root, MPI_Comm com
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
this is due to the use of memory allocation routines such as <TT>malloc
|
||||
</TT>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
All MPI routines in Fortran (except for <TT>MPI_WTIME</TT> and <TT>MPI_WTICK</TT>) have
|
||||
an additional argument <TT>ierr</TT> at the end of the argument list. <TT>ierr
|
||||
</TT>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<TT>call</TT> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
All MPI objects (e.g., <TT>MPI_Datatype</TT>, <TT>MPI_Comm</TT>) are of type <TT>INTEGER
|
||||
</TT>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
All MPI routines (except <TT>MPI_Wtime</TT> and <TT>MPI_Wtick</TT>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
may be changed with <TT>MPI_Comm_set_errhandler</TT> (for communicators),
|
||||
<TT>MPI_File_set_errhandler</TT> (for files), and <TT>MPI_Win_set_errhandler</TT> (for
|
||||
RMA windows). The MPI-1 routine <TT>MPI_Errhandler_set</TT> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarentee that an MPI program can continue past
|
||||
<TT>MPI_ERRORS_RETURN</TT> may be used to cause error values to be returned.
|
||||
Note that MPI does <EM>not</EM> guarentee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
@@ -65,6 +65,6 @@ possible.
|
||||
<DL><DT><B>MPI_ERR_INFO </B> <DD> Invalid Info
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_COMM </B> <DD> Invalid communicator. A common error is to use a null
|
||||
communicator in a call (not even allowed in <tt>MPI_Comm_rank</tt>).
|
||||
communicator in a call (not even allowed in <TT>MPI_Comm_rank</TT>).
|
||||
</DL>
|
||||
</BODY></HTML>
|
||||
|
||||
@@ -32,39 +32,39 @@ with this routine.
|
||||
The MPI standard defined a thread-safe interface but this does not
|
||||
mean that all routines may be called without any thread locks. For
|
||||
example, two threads must not attempt to change the contents of the
|
||||
same <tt>MPI_Info</tt> object concurrently. The user is responsible in this
|
||||
same <TT>MPI_Info</TT> object concurrently. The user is responsible in this
|
||||
case for using some mechanism, such as thread locks, to ensure that
|
||||
only one thread at a time makes use of this routine.
|
||||
<P>
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
All MPI routines in Fortran (except for <TT>MPI_WTIME</TT> and <TT>MPI_WTICK</TT>) have
|
||||
an additional argument <TT>ierr</TT> at the end of the argument list. <TT>ierr
|
||||
</TT>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<TT>call</TT> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
All MPI objects (e.g., <TT>MPI_Datatype</TT>, <TT>MPI_Comm</TT>) are of type <TT>INTEGER
|
||||
</TT>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
All MPI routines (except <TT>MPI_Wtime</TT> and <TT>MPI_Wtick</TT>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
may be changed with <TT>MPI_Comm_set_errhandler</TT> (for communicators),
|
||||
<TT>MPI_File_set_errhandler</TT> (for files), and <TT>MPI_Win_set_errhandler</TT> (for
|
||||
RMA windows). The MPI-1 routine <TT>MPI_Errhandler_set</TT> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarentee that an MPI program can continue past
|
||||
<TT>MPI_ERRORS_RETURN</TT> may be used to cause error values to be returned.
|
||||
Note that MPI does <EM>not</EM> guarentee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL><DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_COMM </B> <DD> Invalid communicator. A common error is to use a null
|
||||
communicator in a call (not even allowed in <tt>MPI_Comm_rank</tt>).
|
||||
communicator in a call (not even allowed in <TT>MPI_Comm_rank</TT>).
|
||||
</DL>
|
||||
</BODY></HTML>
|
||||
|
||||
@@ -19,62 +19,62 @@ int MPI_Comm_compare(MPI_Comm comm1, MPI_Comm comm2, int *result)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL><DT><B>result </B> <DD> integer which is <tt>MPI_IDENT</tt> if the contexts and groups are the
|
||||
same, <tt>MPI_CONGRUENT</tt> if different contexts but identical groups, <tt>MPI_SIMILAR
|
||||
</tt>if different contexts but similar groups, and <tt>MPI_UNEQUAL</tt> otherwise
|
||||
<DL><DT><B>result </B> <DD> integer which is <TT>MPI_IDENT</TT> if the contexts and groups are the
|
||||
same, <TT>MPI_CONGRUENT</TT> if different contexts but identical groups, <TT>MPI_SIMILAR
|
||||
</TT>if different contexts but similar groups, and <TT>MPI_UNEQUAL</TT> otherwise
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Using 'MPI_COMM_NULL' with 'MPI_Comm_compare'</H2>
|
||||
<P>
|
||||
It is an error to use <tt>MPI_COMM_NULL</tt> as one of the arguments to
|
||||
<tt>MPI_Comm_compare</tt>. The relevant sections of the MPI standard are
|
||||
It is an error to use <TT>MPI_COMM_NULL</TT> as one of the arguments to
|
||||
<TT>MPI_Comm_compare</TT>. The relevant sections of the MPI standard are
|
||||
<P>
|
||||
.(2.4.1 Opaque Objects)
|
||||
A null handle argument is an erroneous <tt>IN</tt> argument in MPI calls, unless an
|
||||
A null handle argument is an erroneous <TT>IN</TT> argument in MPI calls, unless an
|
||||
exception is explicitly stated in the text that defines the function.
|
||||
<P>
|
||||
.(5.4.1. Communicator Accessors)
|
||||
where there is no text in <tt>MPI_COMM_COMPARE</tt> allowing a null handle.
|
||||
where there is no text in <TT>MPI_COMM_COMPARE</TT> allowing a null handle.
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
<P>
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
this is due to the use of memory allocation routines such as <TT>malloc
|
||||
</TT>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
(To perform the communicator comparisions, this routine may need to
|
||||
allocate some memory. Memory allocation is not interrupt-safe, and hence
|
||||
this routine is only thread-safe.)
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
All MPI routines in Fortran (except for <TT>MPI_WTIME</TT> and <TT>MPI_WTICK</TT>) have
|
||||
an additional argument <TT>ierr</TT> at the end of the argument list. <TT>ierr
|
||||
</TT>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<TT>call</TT> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
All MPI objects (e.g., <TT>MPI_Datatype</TT>, <TT>MPI_Comm</TT>) are of type <TT>INTEGER
|
||||
</TT>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
All MPI routines (except <TT>MPI_Wtime</TT> and <TT>MPI_Wtick</TT>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
may be changed with <TT>MPI_Comm_set_errhandler</TT> (for communicators),
|
||||
<TT>MPI_File_set_errhandler</TT> (for files), and <TT>MPI_Win_set_errhandler</TT> (for
|
||||
RMA windows). The MPI-1 routine <TT>MPI_Errhandler_set</TT> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarentee that an MPI program can continue past
|
||||
<TT>MPI_ERRORS_RETURN</TT> may be used to cause error values to be returned.
|
||||
Note that MPI does <EM>not</EM> guarentee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL><DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_ARG </B> <DD> Invalid argument. Some argument is invalid and is not
|
||||
identified by a specific error class (e.g., <tt>MPI_ERR_RANK</tt>).
|
||||
identified by a specific error class (e.g., <TT>MPI_ERR_RANK</TT>).
|
||||
</DL>
|
||||
</BODY></HTML>
|
||||
|
||||
@@ -10,7 +10,7 @@ Make a request to form a new intercommunicator
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
int MPI_Comm_connect(const char *port_name, MPI_Info info, int root, MPI_Comm comm,
|
||||
MPI_Comm *newcomm)
|
||||
MPI_Comm * newcomm)
|
||||
</PRE>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
@@ -32,38 +32,38 @@ int MPI_Comm_connect(const char *port_name, MPI_Info info, int root, MPI_Comm co
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
this is due to the use of memory allocation routines such as <TT>malloc
|
||||
</TT>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
All MPI routines in Fortran (except for <TT>MPI_WTIME</TT> and <TT>MPI_WTICK</TT>) have
|
||||
an additional argument <TT>ierr</TT> at the end of the argument list. <TT>ierr
|
||||
</TT>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<TT>call</TT> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
All MPI objects (e.g., <TT>MPI_Datatype</TT>, <TT>MPI_Comm</TT>) are of type <TT>INTEGER
|
||||
</TT>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
All MPI routines (except <TT>MPI_Wtime</TT> and <TT>MPI_Wtick</TT>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
may be changed with <TT>MPI_Comm_set_errhandler</TT> (for communicators),
|
||||
<TT>MPI_File_set_errhandler</TT> (for files), and <TT>MPI_Win_set_errhandler</TT> (for
|
||||
RMA windows). The MPI-1 routine <TT>MPI_Errhandler_set</TT> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarentee that an MPI program can continue past
|
||||
<TT>MPI_ERRORS_RETURN</TT> may be used to cause error values to be returned.
|
||||
Note that MPI does <EM>not</EM> guarentee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL><DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_COMM </B> <DD> Invalid communicator. A common error is to use a null
|
||||
communicator in a call (not even allowed in <tt>MPI_Comm_rank</tt>).
|
||||
communicator in a call (not even allowed in <TT>MPI_Comm_rank</TT>).
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_INFO </B> <DD> Invalid Info
|
||||
</DL>
|
||||
|
||||
@@ -9,13 +9,13 @@
|
||||
Creates a new communicator
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
int MPI_Comm_create(MPI_Comm comm, MPI_Group group, MPI_Comm *newcomm)
|
||||
int MPI_Comm_create(MPI_Comm comm, MPI_Group group, MPI_Comm * newcomm)
|
||||
</PRE>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>comm </B><DD>communicator (handle)
|
||||
|
||||
<DT><B>group </B><DD>group, which is a subset of the group of <tt>comm</tt> (handle)
|
||||
<DT><B>group </B><DD>group, which is a subset of the group of <TT>comm</TT> (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
@@ -27,43 +27,43 @@ int MPI_Comm_create(MPI_Comm comm, MPI_Group group, MPI_Comm *newcomm)
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
this is due to the use of memory allocation routines such as <TT>malloc
|
||||
</TT>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
All MPI routines in Fortran (except for <TT>MPI_WTIME</TT> and <TT>MPI_WTICK</TT>) have
|
||||
an additional argument <TT>ierr</TT> at the end of the argument list. <TT>ierr
|
||||
</TT>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<TT>call</TT> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
All MPI objects (e.g., <TT>MPI_Datatype</TT>, <TT>MPI_Comm</TT>) are of type <TT>INTEGER
|
||||
</TT>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
All MPI routines (except <TT>MPI_Wtime</TT> and <TT>MPI_Wtick</TT>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
may be changed with <TT>MPI_Comm_set_errhandler</TT> (for communicators),
|
||||
<TT>MPI_File_set_errhandler</TT> (for files), and <TT>MPI_Win_set_errhandler</TT> (for
|
||||
RMA windows). The MPI-1 routine <TT>MPI_Errhandler_set</TT> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarentee that an MPI program can continue past
|
||||
<TT>MPI_ERRORS_RETURN</TT> may be used to cause error values to be returned.
|
||||
Note that MPI does <EM>not</EM> guarentee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL><DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_COMM </B> <DD> Invalid communicator. A common error is to use a null
|
||||
communicator in a call (not even allowed in <tt>MPI_Comm_rank</tt>).
|
||||
communicator in a call (not even allowed in <TT>MPI_Comm_rank</TT>).
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_GROUP </B> <DD> Null or invalid group passed to function.
|
||||
</DL>
|
||||
<P>
|
||||
<H0>See Also</H0>
|
||||
<H2>See Also</H2>
|
||||
MPI_Comm_free
|
||||
<br>
|
||||
<BR>
|
||||
</BODY></HTML>
|
||||
|
||||
@@ -9,8 +9,8 @@
|
||||
Create a communicator error handler
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
int MPI_Comm_create_errhandler(MPI_Comm_errhandler_function *comm_errhandler_fn,
|
||||
MPI_Errhandler *errhandler)
|
||||
int MPI_Comm_create_errhandler(MPI_Comm_errhandler_function * comm_errhandler_fn,
|
||||
MPI_Errhandler * errhandler)
|
||||
</PRE>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL><DT><B>comm_errhandler_fn </B> <DD> user defined error handling procedure (function)
|
||||
@@ -30,40 +30,40 @@ void MPI_Comm_errhandler_function(MPI_Comm *comm, int *rc);
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
this is due to the use of memory allocation routines such as <TT>malloc
|
||||
</TT>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
All MPI routines in Fortran (except for <TT>MPI_WTIME</TT> and <TT>MPI_WTICK</TT>) have
|
||||
an additional argument <TT>ierr</TT> at the end of the argument list. <TT>ierr
|
||||
</TT>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<TT>call</TT> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
All MPI objects (e.g., <TT>MPI_Datatype</TT>, <TT>MPI_Comm</TT>) are of type <TT>INTEGER
|
||||
</TT>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
All MPI routines (except <TT>MPI_Wtime</TT> and <TT>MPI_Wtick</TT>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
may be changed with <TT>MPI_Comm_set_errhandler</TT> (for communicators),
|
||||
<TT>MPI_File_set_errhandler</TT> (for files), and <TT>MPI_Win_set_errhandler</TT> (for
|
||||
RMA windows). The MPI-1 routine <TT>MPI_Errhandler_set</TT> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarentee that an MPI program can continue past
|
||||
<TT>MPI_ERRORS_RETURN</TT> may be used to cause error values to be returned.
|
||||
Note that MPI does <EM>not</EM> guarentee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL><DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_COMM </B> <DD> Invalid communicator. A common error is to use a null
|
||||
communicator in a call (not even allowed in <tt>MPI_Comm_rank</tt>).
|
||||
communicator in a call (not even allowed in <TT>MPI_Comm_rank</TT>).
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_OTHER </B> <DD> Other error; use <tt>MPI_Error_string</tt> to get more information
|
||||
<DL><DT><B>MPI_ERR_OTHER </B> <DD> Other error; use <TT>MPI_Error_string</TT> to get more information
|
||||
about this error code.
|
||||
</DL>
|
||||
</BODY></HTML>
|
||||
|
||||
@@ -15,7 +15,7 @@ int MPI_Comm_create_group(MPI_Comm comm, MPI_Group group, int tag, MPI_Comm * ne
|
||||
<DL>
|
||||
<DT><B>comm </B><DD>communicator (handle)
|
||||
|
||||
<DT><B>group </B><DD>group, which is a subset of the group of <tt>comm</tt> (handle)
|
||||
<DT><B>group </B><DD>group, which is a subset of the group of <TT>comm</TT> (handle)
|
||||
|
||||
<DT><B>tag </B><DD>safe tag unused by other communication
|
||||
</DL>
|
||||
@@ -29,43 +29,43 @@ int MPI_Comm_create_group(MPI_Comm comm, MPI_Group group, int tag, MPI_Comm * ne
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
this is due to the use of memory allocation routines such as <TT>malloc
|
||||
</TT>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
All MPI routines in Fortran (except for <TT>MPI_WTIME</TT> and <TT>MPI_WTICK</TT>) have
|
||||
an additional argument <TT>ierr</TT> at the end of the argument list. <TT>ierr
|
||||
</TT>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<TT>call</TT> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
All MPI objects (e.g., <TT>MPI_Datatype</TT>, <TT>MPI_Comm</TT>) are of type <TT>INTEGER
|
||||
</TT>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
All MPI routines (except <TT>MPI_Wtime</TT> and <TT>MPI_Wtick</TT>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
may be changed with <TT>MPI_Comm_set_errhandler</TT> (for communicators),
|
||||
<TT>MPI_File_set_errhandler</TT> (for files), and <TT>MPI_Win_set_errhandler</TT> (for
|
||||
RMA windows). The MPI-1 routine <TT>MPI_Errhandler_set</TT> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarentee that an MPI program can continue past
|
||||
<TT>MPI_ERRORS_RETURN</TT> may be used to cause error values to be returned.
|
||||
Note that MPI does <EM>not</EM> guarentee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL><DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_COMM </B> <DD> Invalid communicator. A common error is to use a null
|
||||
communicator in a call (not even allowed in <tt>MPI_Comm_rank</tt>).
|
||||
communicator in a call (not even allowed in <TT>MPI_Comm_rank</TT>).
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_GROUP </B> <DD> Null or invalid group passed to function.
|
||||
</DL>
|
||||
<P>
|
||||
<H0>See Also</H0>
|
||||
<H2>See Also</H2>
|
||||
MPI_Comm_free
|
||||
<br>
|
||||
<BR>
|
||||
</BODY></HTML>
|
||||
|
||||
@@ -9,16 +9,16 @@
|
||||
Create a new attribute key
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
int MPI_Comm_create_keyval(MPI_Comm_copy_attr_function *comm_copy_attr_fn,
|
||||
MPI_Comm_delete_attr_function *comm_delete_attr_fn,
|
||||
int MPI_Comm_create_keyval(MPI_Comm_copy_attr_function * comm_copy_attr_fn,
|
||||
MPI_Comm_delete_attr_function * comm_delete_attr_fn,
|
||||
int *comm_keyval, void *extra_state)
|
||||
</PRE>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>comm_copy_attr_fn </B><DD>Copy callback function for <tt>keyval
|
||||
</tt>
|
||||
<DT><B>comm_delete_attr_fn </B><DD>Delete callback function for <tt>keyval
|
||||
</tt>
|
||||
<DT><B>comm_copy_attr_fn </B><DD>Copy callback function for <TT>keyval
|
||||
</TT>
|
||||
<DT><B>comm_delete_attr_fn </B><DD>Delete callback function for <TT>keyval
|
||||
</TT>
|
||||
<DT><B>extra_state </B><DD>Extra state for callback functions
|
||||
</DL>
|
||||
<P>
|
||||
@@ -39,17 +39,17 @@ Default copy and delete functions are available. These are
|
||||
</DL>
|
||||
<P>
|
||||
There are subtle differences between C and Fortran that require that the
|
||||
copy_fn be written in the same language from which <tt>MPI_Comm_create_keyval
|
||||
</tt>is called.
|
||||
copy_fn be written in the same language from which <TT>MPI_Comm_create_keyval
|
||||
</TT>is called.
|
||||
This should not be a problem for most users; only programmers using both
|
||||
Fortran and C in the same program need to be sure that they follow this rule.
|
||||
<P>
|
||||
<P>
|
||||
<H2>Return value from attribute callbacks</H2>
|
||||
The MPI-2 versions of the attribute callbacks should return either
|
||||
<tt>MPI_SUCCESS</tt> on success or a valid MPI error code or class on failure.
|
||||
<TT>MPI_SUCCESS</TT> on success or a valid MPI error code or class on failure.
|
||||
The MPI standard is ambiguous on this point, but as MPI-2 provides
|
||||
the routines <tt>MPI_Add_error_class</tt> and <tt>MPI_Add_error_code</tt> that allow the
|
||||
the routines <TT>MPI_Add_error_class</TT> and <TT>MPI_Add_error_code</TT> that allow the
|
||||
user to define and use MPI error codes and classes.
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
@@ -57,38 +57,38 @@ user to define and use MPI error codes and classes.
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
this is due to the use of memory allocation routines such as <TT>malloc
|
||||
</TT>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
All MPI routines in Fortran (except for <TT>MPI_WTIME</TT> and <TT>MPI_WTICK</TT>) have
|
||||
an additional argument <TT>ierr</TT> at the end of the argument list. <TT>ierr
|
||||
</TT>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<TT>call</TT> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
All MPI objects (e.g., <TT>MPI_Datatype</TT>, <TT>MPI_Comm</TT>) are of type <TT>INTEGER
|
||||
</TT>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
All MPI routines (except <TT>MPI_Wtime</TT> and <TT>MPI_Wtick</TT>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
may be changed with <TT>MPI_Comm_set_errhandler</TT> (for communicators),
|
||||
<TT>MPI_File_set_errhandler</TT> (for files), and <TT>MPI_Win_set_errhandler</TT> (for
|
||||
RMA windows). The MPI-1 routine <TT>MPI_Errhandler_set</TT> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarentee that an MPI program can continue past
|
||||
<TT>MPI_ERRORS_RETURN</TT> may be used to cause error values to be returned.
|
||||
Note that MPI does <EM>not</EM> guarentee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL><DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<P>
|
||||
<H0>See Also</H0>
|
||||
<H2>See Also</H2>
|
||||
MPI_Comm_free_keyval
|
||||
<br>
|
||||
<BR>
|
||||
</BODY></HTML>
|
||||
|
||||
@@ -23,44 +23,44 @@ int MPI_Comm_delete_attr(MPI_Comm comm, int comm_keyval)
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
this is due to the use of memory allocation routines such as <TT>malloc
|
||||
</TT>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
All MPI routines in Fortran (except for <TT>MPI_WTIME</TT> and <TT>MPI_WTICK</TT>) have
|
||||
an additional argument <TT>ierr</TT> at the end of the argument list. <TT>ierr
|
||||
</TT>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<TT>call</TT> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
All MPI objects (e.g., <TT>MPI_Datatype</TT>, <TT>MPI_Comm</TT>) are of type <TT>INTEGER
|
||||
</TT>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
All MPI routines (except <TT>MPI_Wtime</TT> and <TT>MPI_Wtick</TT>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
may be changed with <TT>MPI_Comm_set_errhandler</TT> (for communicators),
|
||||
<TT>MPI_File_set_errhandler</TT> (for files), and <TT>MPI_Win_set_errhandler</TT> (for
|
||||
RMA windows). The MPI-1 routine <TT>MPI_Errhandler_set</TT> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarentee that an MPI program can continue past
|
||||
<TT>MPI_ERRORS_RETURN</TT> may be used to cause error values to be returned.
|
||||
Note that MPI does <EM>not</EM> guarentee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL><DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_COMM </B> <DD> Invalid communicator. A common error is to use a null
|
||||
communicator in a call (not even allowed in <tt>MPI_Comm_rank</tt>).
|
||||
communicator in a call (not even allowed in <TT>MPI_Comm_rank</TT>).
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_ARG </B> <DD> This error class is associated with an error code that
|
||||
indicates that an attempt was made to free one of the permanent keys.
|
||||
</DL>
|
||||
<P>
|
||||
<H0>See Also</H0>
|
||||
<H2>See Also</H2>
|
||||
MPI_Comm_set_attr, MPI_Comm_create_keyval
|
||||
<br>
|
||||
<BR>
|
||||
</BODY></HTML>
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user