mac mpi
This commit is contained in:
Bassem Girgis
BIN
macx64/mpi/mpich/bin/hydra_nameserver
Executable file
BIN
macx64/mpi/mpich/bin/hydra_nameserver
Executable file
Binary file not shown.
BIN
macx64/mpi/mpich/bin/hydra_persist
Executable file
BIN
macx64/mpi/mpich/bin/hydra_persist
Executable file
Binary file not shown.
BIN
macx64/mpi/mpich/bin/hydra_pmi_proxy
Executable file
BIN
macx64/mpi/mpich/bin/hydra_pmi_proxy
Executable file
Binary file not shown.
305
macx64/mpi/mpich/bin/mpicc
Executable file
305
macx64/mpi/mpich/bin/mpicc
Executable file
@@ -0,0 +1,305 @@
|
||||
#! /bin/bash
|
||||
#
|
||||
# (C) 2006 by Argonne National Laboratory.
|
||||
# See COPYRIGHT in top-level directory.
|
||||
#
|
||||
# mpicc
|
||||
# Simple script to compile and/or link MPI programs.
|
||||
# This script knows the default flags and libraries, and can handle
|
||||
# alternative C compilers and the associated flags and libraries.
|
||||
# The important terms are:
|
||||
# includedir, libdir - Directories containing an *installed* mpich
|
||||
# prefix, execprefix - Often used to define includedir and libdir
|
||||
# CC - C compiler
|
||||
# WRAPPER_CFLAGS - Any special flags needed to compile
|
||||
# WRAPPER_LDFLAGS - Any special flags needed to link
|
||||
# WRAPPER_LIBS - Any special libraries needed in order to link
|
||||
#
|
||||
# We assume that (a) the C compiler can both compile and link programs
|
||||
#
|
||||
# Handling of command-line options:
|
||||
# This is a little tricky because some options may contain blanks.
|
||||
#
|
||||
# Special issues with shared libraries - todo
|
||||
#
|
||||
# --------------------------------------------------------------------------
|
||||
# Set the default values of all variables.
|
||||
#
|
||||
# Directory locations: Fixed for any MPI implementation.
|
||||
# Set from the directory arguments to configure (e.g., --prefix=/usr/local)
|
||||
prefix=/Users/brgirgis/Documents/code/idiscovery/cpp-thirdparty-src/mpi/mpich/install/3.3.1
|
||||
exec_prefix=/Users/brgirgis/Documents/code/idiscovery/cpp-thirdparty-src/mpi/mpich/install/3.3.1
|
||||
sysconfdir=/Users/brgirgis/Documents/code/idiscovery/cpp-thirdparty-src/mpi/mpich/install/3.3.1/etc
|
||||
includedir=/Users/brgirgis/Documents/code/idiscovery/cpp-thirdparty-src/mpi/mpich/install/3.3.1/include
|
||||
libdir=/Users/brgirgis/Documents/code/idiscovery/cpp-thirdparty-src/mpi/mpich/install/3.3.1/lib
|
||||
|
||||
# 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.3.1"
|
||||
|
||||
enable_wrapper_rpath="yes"
|
||||
|
||||
# How to pass a linker flag through the compiler.
|
||||
wl="-Wl,"
|
||||
|
||||
# Static library suffix (normally "a").
|
||||
libext="a"
|
||||
|
||||
# Shared library suffix (normally "so").
|
||||
shlibext="dylib"
|
||||
|
||||
# Format of library name prefix.
|
||||
libname_spec="lib\$name"
|
||||
|
||||
# Library names that the linker finds when passed -lNAME.
|
||||
library_names_spec="\$libname\$shrext"
|
||||
|
||||
# Flag to hardcode $libdir into a binary during linking.
|
||||
# This must work even if $libdir does not exist.
|
||||
hardcode_libdir_flag_spec=""
|
||||
|
||||
# Whether we need a single -rpath flag with a separated argument.
|
||||
hardcode_libdir_separator=""
|
||||
|
||||
# Set to yes if using DIR/libNAME.so during linking hardcodes DIR into the
|
||||
# resulting binary.
|
||||
hardcode_direct="no"
|
||||
|
||||
# Set to yes if using the -LDIR flag during linking hardcodes DIR into the
|
||||
# resulting binary.
|
||||
hardcode_minus_L="no"
|
||||
|
||||
|
||||
# Internal variables
|
||||
# Show is set to echo to cause the compilation command to be echoed instead
|
||||
# of executed.
|
||||
Show=
|
||||
#
|
||||
# End of initialization of variables
|
||||
#---------------------------------------------------------------------
|
||||
# Environment Variables.
|
||||
# The environment variables MPICH_CC may be used to override the
|
||||
# default choices.
|
||||
# In addition, if there is a file $sysconfdir/mpicc-$CCname.conf,
|
||||
# where CCname is the name of the compiler with all spaces replaced by hyphens
|
||||
# (e.g., "cc -64" becomes "cc--64", that file is sources, allowing other
|
||||
# changes to the compilation environment. See the variables used by the
|
||||
# script (defined above)
|
||||
# Added MPICH_CC_OLD, MPICH_CC can be used to prefix CC with external utility,
|
||||
# e.g. setenv MPICH_CC 'eval linkcache $MPICH_CC_OLD'
|
||||
if [ -n "$MPICH_CC" ] ; then
|
||||
MPICH_CC_OLD="$CC"
|
||||
CC="$MPICH_CC"
|
||||
CCname=`echo $CC | sed 's/ /-/g'`
|
||||
if [ -s $sysconfdir/mpicc-$CCname.conf ] ; then
|
||||
. $sysconfdir/mpicc-$CCname.conf
|
||||
fi
|
||||
fi
|
||||
# Allow a profiling option to be selected through an environment variable
|
||||
if [ -n "$MPICC_PROFILE" ] ; then
|
||||
profConf=$MPICC_PROFILE
|
||||
fi
|
||||
#
|
||||
# ------------------------------------------------------------------------
|
||||
# Argument processing.
|
||||
# This is somewhat awkward because of the handling of arguments within
|
||||
# the shell. We want to handle arguments that include spaces without
|
||||
# loosing the spacing (an alternative would be to use a more powerful
|
||||
# scripting language that would allow us to retain the array of values,
|
||||
# which the basic (rather than enhanced) Bourne shell does not.
|
||||
#
|
||||
# Look through the arguments for arguments that indicate compile only.
|
||||
# If these are *not* found, add the library options
|
||||
|
||||
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
|
||||
case "$arg" in
|
||||
# ----------------------------------------------------------------
|
||||
# Compiler options that affect whether we are linking or no
|
||||
-c|-S|-E|-M|-MM)
|
||||
# The compiler links by default
|
||||
linking=no
|
||||
;;
|
||||
# ----------------------------------------------------------------
|
||||
# Options that control how we use mpicc (e.g., -show,
|
||||
# -cc=* -config=*
|
||||
-static)
|
||||
interlib_deps=no
|
||||
;;
|
||||
-static-mpi)
|
||||
interlib_deps=no
|
||||
static_mpi=yes
|
||||
addarg=no
|
||||
;;
|
||||
-echo)
|
||||
addarg=no
|
||||
set -x
|
||||
;;
|
||||
-cc=*)
|
||||
CC=`echo A$arg | sed -e 's/A-cc=//g'`
|
||||
addarg=no
|
||||
;;
|
||||
-show)
|
||||
addarg=no
|
||||
Show=echo
|
||||
;;
|
||||
-config=*)
|
||||
addarg=no
|
||||
CCname=`echo A$arg | sed -e 's/A-config=//g'`
|
||||
if [ -s "$sysconfdir/mpicc-$CCname.conf" ] ; then
|
||||
. "$sysconfdir/mpicc-$CCname.conf"
|
||||
else
|
||||
echo "Configuration file mpicc-$CCname.conf not found"
|
||||
fi
|
||||
;;
|
||||
-compile-info|-compile_info)
|
||||
# -compile_info included for backward compatibility
|
||||
Show=echo
|
||||
addarg=no
|
||||
;;
|
||||
-link-info|-link_info)
|
||||
# -link_info included for backward compatibility
|
||||
Show=echo
|
||||
addarg=no
|
||||
;;
|
||||
-v)
|
||||
# Pass this argument to the compiler as well.
|
||||
echo "mpicc for MPICH version $MPICH_VERSION"
|
||||
# if there is only 1 argument, it must be -v.
|
||||
if [ "$#" -eq "1" ] ; then
|
||||
linking=no
|
||||
fi
|
||||
;;
|
||||
-profile=*)
|
||||
# Pass the name of a profiling configuration. As
|
||||
# a special case, lib<name>.so or lib<name>.la may be used
|
||||
# if the library is in $libdir
|
||||
profConf=`echo A$arg | sed -e 's/A-profile=//g'`
|
||||
addarg=no
|
||||
# Loading the profConf file is handled below
|
||||
;;
|
||||
-nativelinking)
|
||||
# Internal option to use native compiler for linking without MPI libraries
|
||||
nativelinking=yes
|
||||
addarg=no
|
||||
;;
|
||||
-help)
|
||||
NC=`echo "$CC" | sed 's%\/% %g' | awk '{print $NF}' -`
|
||||
if [ -f "$sysconfdir/mpixxx_opts.conf" ] ; then
|
||||
. $sysconfdir/mpixxx_opts.conf
|
||||
echo " -cc=xxx - Reset the native compiler to xxx."
|
||||
else
|
||||
if [ -f "./mpixxx_opts.conf" ] ; then
|
||||
. ./mpixxx_opts.conf
|
||||
echo " -cc=xxx - Reset the native compiler to xxx."
|
||||
fi
|
||||
fi
|
||||
exit 0
|
||||
;;
|
||||
*)
|
||||
;;
|
||||
|
||||
esac
|
||||
if [ $addarg = no ] ; then
|
||||
unset allargs[$argno]
|
||||
fi
|
||||
# Some versions of bash do not accept ((argno++))
|
||||
argno=`expr $argno + 1`
|
||||
done
|
||||
|
||||
if [ $# -eq 0 ] ; then
|
||||
echo "Error: Command line argument is needed!"
|
||||
"$0" -help
|
||||
exit 1
|
||||
fi
|
||||
|
||||
# -----------------------------------------------------------------------
|
||||
# Derived variables. These are assembled from variables set from the
|
||||
# default, environment, configuration file (if any) and command-line
|
||||
# options (if any)
|
||||
|
||||
PROFILE_FOO=
|
||||
# Handle the case of a profile switch
|
||||
if [ -n "$profConf" ] ; then
|
||||
profConffile=
|
||||
if [ -s "$libdir/lib$profConf.a" -o -s "$libdir/lib$profConf.so" ] ; then
|
||||
PROFILE_FOO="-l$profConf"
|
||||
elif [ -s "$sysconfdir/$profConf.conf" ] ; then
|
||||
profConffile="$sysconfdir/$profConf.conf"
|
||||
elif [ -s "$profConf.conf" ] ; then
|
||||
profConffile="$profConf.conf"
|
||||
else
|
||||
echo "Profiling configuration file $profConf.conf not found in $sysconfdir"
|
||||
fi
|
||||
if [ -n "$profConffile" -a -s "$profConffile" ] ; then
|
||||
. $profConffile
|
||||
fi
|
||||
fi
|
||||
|
||||
final_cflags=" "
|
||||
final_cppflags=" "
|
||||
final_ldflags=" -Wl,-flat_namespace"
|
||||
final_libs=""
|
||||
if test "yes" = "no" -o "${interlib_deps}" = "no" ; then
|
||||
final_ldflags="${final_ldflags} -Wl,-flat_namespace"
|
||||
final_libs="${final_libs} -lm -lpthread "
|
||||
fi
|
||||
|
||||
# -----------------------------------------------------------------------
|
||||
#
|
||||
# A temporary statement to invoke the compiler
|
||||
# Place the -L before any args incase there are any mpi libraries in there.
|
||||
# Eventually, we'll want to move this after any non-MPI implementation
|
||||
# libraries.
|
||||
# We use a single invocation of the compiler. This will be adequate until
|
||||
# we run into a system that uses a separate linking command. With any luck,
|
||||
# such archaic systems are no longer with us. This also lets us
|
||||
# accept any argument; we don't need to know if we've seen a source
|
||||
# file or an object file. Instead, we just check for an option that
|
||||
# suppressing linking, such as -c or -M.
|
||||
if [ "$linking" = yes ] ; then
|
||||
# Attempt to encode rpath info into the executable if the user has not
|
||||
# disabled rpath usage and some flavor of rpath makes sense on this
|
||||
# platform.
|
||||
# TODO configure and config.rpath are computing more sophisticated rpath
|
||||
# schemes than this simple one. Consider updating this logic accordingly.
|
||||
if test "X$enable_wrapper_rpath" = "Xyes" ; then
|
||||
eval rpath_flags=\"${hardcode_libdir_flag_spec}\"
|
||||
else
|
||||
rpath_flags=""
|
||||
fi
|
||||
|
||||
if [ "$nativelinking" = 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 -lpmpi $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 -lpmpi $PROFILE_POSTLIB ${final_libs} ${fabric_dep}
|
||||
fi
|
||||
rc=$?
|
||||
fi
|
||||
else
|
||||
$Show $CC ${final_cppflags} $PROFILE_INCPATHS ${final_cflags} "${allargs[@]}" -I$includedir
|
||||
rc=$?
|
||||
fi
|
||||
|
||||
exit $rc
|
||||
BIN
macx64/mpi/mpich/bin/mpichversion
Executable file
BIN
macx64/mpi/mpich/bin/mpichversion
Executable file
Binary file not shown.
1
macx64/mpi/mpich/bin/mpiexec
Symbolic link
1
macx64/mpi/mpich/bin/mpiexec
Symbolic link
@@ -0,0 +1 @@
|
||||
mpiexec.hydra
|
||||
BIN
macx64/mpi/mpich/bin/mpiexec.hydra
Executable file
BIN
macx64/mpi/mpich/bin/mpiexec.hydra
Executable file
Binary file not shown.
1
macx64/mpi/mpich/bin/mpirun
Symbolic link
1
macx64/mpi/mpich/bin/mpirun
Symbolic link
@@ -0,0 +1 @@
|
||||
mpiexec.hydra
|
||||
BIN
macx64/mpi/mpich/bin/mpivars
Executable file
BIN
macx64/mpi/mpich/bin/mpivars
Executable file
Binary file not shown.
127
macx64/mpi/mpich/bin/parkill
Executable file
127
macx64/mpi/mpich/bin/parkill
Executable file
@@ -0,0 +1,127 @@
|
||||
#! /usr/bin/perl
|
||||
# -*- Mode: perl; -*-
|
||||
#
|
||||
# Kill all processes running a specified command
|
||||
#
|
||||
# Many systems also have the "killall" command; this should be used instead
|
||||
# if it is available.
|
||||
#
|
||||
# This script relies on the ps command; where possible, it uses the
|
||||
# /proc/<pid>/cmdline interface to more reliably access the commandline
|
||||
# (to avoid matching command line parameters as if they were functions).
|
||||
#
|
||||
$user = $ENV{'LOGNAME'};
|
||||
$progname = "";
|
||||
$noaddresses = 1;
|
||||
$debug = 0;
|
||||
$verbose = 0;
|
||||
$testing = 0;
|
||||
foreach $_ (@ARGV) {
|
||||
if (/-debug/) {
|
||||
$debug = 1;
|
||||
}
|
||||
elsif (/-verbose/) {
|
||||
$verbose = 1;
|
||||
}
|
||||
elsif (/-user=(.*)/) {
|
||||
$user = $1;
|
||||
}
|
||||
elsif (/-help/ || /-usage/) {
|
||||
print STDOUT "$0 [ -debug ] [ -verbose ] [ -user=name ] program\n";
|
||||
print STDOUT "Kill all processes running \"program\". To use the -user option
|
||||
you must have superuser privilege.\n";
|
||||
exit(1);
|
||||
}
|
||||
$progname = $_;
|
||||
}
|
||||
|
||||
if ( $progname eq "" ) {
|
||||
print STDERR "You must specify a program name\n";
|
||||
exit(1);
|
||||
}
|
||||
|
||||
print "user is $user\n" if $debug;
|
||||
#
|
||||
# Get pids
|
||||
$remoteps = "ps";
|
||||
$sysname=`uname -s`;
|
||||
chop $sysname;
|
||||
# Try to get nicer behavior from GNU ps.
|
||||
$ENV{'COLUMNS'} = 200;
|
||||
$ENV{'PS_PERSONALITY'} = "linux";
|
||||
if ($sysname eq "Linux") {
|
||||
print "linux style ps\n" if $debug;
|
||||
# The -width option can cause trouble, even with GNU ps, if the ps
|
||||
# program either doesn't support it or
|
||||
#$psopts = "-width 200 -lfu"; # LINUX
|
||||
$psopts = "-lfu"; # LINUX
|
||||
$pidloc = 3; # 4 sometimes?
|
||||
}
|
||||
elsif ($sysname eq "SunOS" || $sysname eq "IRIX64") {
|
||||
print "solaris style ps\n" if $debug;
|
||||
$psopts = "-fu"; # Solaris
|
||||
$pidloc = 2;
|
||||
}
|
||||
elsif ($sysname eq "OSF1" ) {
|
||||
$psopts = "-fu";
|
||||
$pidloc = 1;
|
||||
}
|
||||
elsif ($sysname eq "Darwin") {
|
||||
$psopts = "-aux -U";
|
||||
$pidloc = 1;
|
||||
}
|
||||
else {
|
||||
print STDERR "Unsupported system \"$sysname\"\n";
|
||||
exit(1);
|
||||
}
|
||||
|
||||
open( FD, "$remoteps $psopts $user |" ) || die "Cannot execute ps\n";
|
||||
|
||||
while (<FD>) {
|
||||
print $_ if $verbose;
|
||||
# Skip lines that may match this command
|
||||
if (/tcsh/) { next; }
|
||||
if (/grep/) { next; }
|
||||
if (/perl/) { next; }
|
||||
if (/\/bin\/sh /) { next; }
|
||||
if ($progname ne "mpiexec" && /mpiexec/) { next; }
|
||||
print $_ if $debug;
|
||||
|
||||
my @items = split(/\s+/);
|
||||
my $pid = $items[$pidloc];
|
||||
print "PID for this job is $pid\n" if $debug;
|
||||
my $procfile = "/proc/$pid/cmdline";
|
||||
print "Looking for $procfile\n" if $debug;
|
||||
# We *CANNOT USE* -s with a file in /proc because -s filename returns
|
||||
# false alwyas ! (BUG BUG BUG). Instead, we try to open and read from it
|
||||
$rc = open PFD, "<$procfile";
|
||||
if ($rc) {
|
||||
my $cmdline = <PFD>;
|
||||
$cmdline =~ s/\r?\n//;
|
||||
print "Cmdline in /proc/$pid is $cmdline\n" if $debug;
|
||||
if ($cmdline =~ /^$progname/ || $cmdline =~ /^\.\/$progname/) {
|
||||
print "Found $progname in /proc/$pid/cmdline\n" if $debug;
|
||||
$pids[$#pids+1] = @items[$pidloc];
|
||||
}
|
||||
close PFD;
|
||||
}
|
||||
else {
|
||||
# Just try to match the commandline to the entire ps output.
|
||||
if (/$progname/) {
|
||||
$pids[$#pids+1] = @items[$pidloc];
|
||||
}
|
||||
}
|
||||
}
|
||||
close FD;
|
||||
|
||||
if ($#pids >= 0) {
|
||||
print "Processes to kill are " . join(',',@pids) . "\n" if $debug;
|
||||
if ($testing) { exit 0; }
|
||||
foreach my $sig ("INT","QUIT","KILL") {
|
||||
my $cnt = kill $sig, @pids;
|
||||
print "Signaled (SIG$sig) $cnt processes\n" if ($debug || $verbose);
|
||||
}
|
||||
}
|
||||
else {
|
||||
print "No processes matched $progname for user $user\n" if $verbose;
|
||||
}
|
||||
2296
macx64/mpi/mpich/include/mpi.h
Normal file
2296
macx64/mpi/mpich/include/mpi.h
Normal file
File diff suppressed because it is too large
Load Diff
551
macx64/mpi/mpich/include/mpio.h
Normal file
551
macx64/mpi/mpich/include/mpio.h
Normal file
@@ -0,0 +1,551 @@
|
||||
/* -*- Mode: C; c-basic-offset:4 ; -*- */
|
||||
/*
|
||||
*
|
||||
* Copyright (C) 1997 University of Chicago.
|
||||
* See COPYRIGHT notice in top-level directory.
|
||||
*/
|
||||
|
||||
/* user include file for MPI-IO programs */
|
||||
|
||||
#ifndef MPIO_INCLUDE
|
||||
#define MPIO_INCLUDE
|
||||
|
||||
#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
|
||||
|
||||
#define ROMIO_VERSION 126 /* version 1.2.6 */
|
||||
|
||||
/* define MPI-IO datatypes and constants */
|
||||
|
||||
#ifndef MPI_FILE_DEFINED
|
||||
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
|
||||
#define MPIO_Request MPI_Request
|
||||
#define MPIO_USES_MPI_REQUEST
|
||||
/* Also rename the MPIO routines to get the MPI versions */
|
||||
#define MPIO_Wait MPI_Wait
|
||||
#define MPIO_Test MPI_Test
|
||||
#define PMPIO_Wait PMPI_Wait
|
||||
#define PMPIO_Test PMPI_Test
|
||||
#endif
|
||||
#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
|
||||
#define HAVE_MPI_DATAREP_FUNCTIONS
|
||||
typedef int (MPI_Datarep_conversion_function)(void *, MPI_Datatype, int,
|
||||
void *, MPI_Offset, void *);
|
||||
typedef int (MPI_Datarep_extent_function)(MPI_Datatype datatype, MPI_Aint *,
|
||||
void *);
|
||||
#endif
|
||||
#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;
|
||||
# define MPI_INFO_NULL ((MPI_Info) 0)
|
||||
# define MPI_MAX_INFO_KEY 255
|
||||
# define MPI_MAX_INFO_VAL 1024
|
||||
#endif
|
||||
|
||||
#define MPI_MODE_RDONLY 2 /* ADIO_RDONLY */
|
||||
#define MPI_MODE_RDWR 8 /* ADIO_RDWR */
|
||||
#define MPI_MODE_WRONLY 4 /* ADIO_WRONLY */
|
||||
#define MPI_MODE_CREATE 1 /* ADIO_CREATE */
|
||||
#define MPI_MODE_EXCL 64 /* ADIO_EXCL */
|
||||
#define MPI_MODE_DELETE_ON_CLOSE 16 /* ADIO_DELETE_ON_CLOSE */
|
||||
#define MPI_MODE_UNIQUE_OPEN 32 /* ADIO_UNIQUE_OPEN */
|
||||
#define MPI_MODE_APPEND 128 /* ADIO_APPEND */
|
||||
#define MPI_MODE_SEQUENTIAL 256 /* ADIO_SEQUENTIAL */
|
||||
|
||||
#define MPI_DISPLACEMENT_CURRENT -54278278
|
||||
|
||||
#ifndef MPICH
|
||||
/* FIXME: Make sure that we get a consistent definition of MPI_FILE_NULL
|
||||
in MPICH */
|
||||
/* MPICH defines null object handles differently */
|
||||
#define MPI_FILE_NULL ((MPI_File) 0)
|
||||
#endif
|
||||
#define MPIO_REQUEST_NULL ((MPIO_Request) 0)
|
||||
|
||||
#define MPI_SEEK_SET 600
|
||||
#define MPI_SEEK_CUR 602
|
||||
#define MPI_SEEK_END 604
|
||||
|
||||
/* Open MPI: don't define MPI_MAX_DATAREP_STRING here; it's defined in
|
||||
OMPI's mpi.h. */
|
||||
#ifndef OPEN_MPI
|
||||
#define MPI_MAX_DATAREP_STRING 128
|
||||
#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
|
||||
# define MPI_ORDER_FORTRAN 57
|
||||
# define MPI_DISTRIBUTE_BLOCK 121
|
||||
# define MPI_DISTRIBUTE_CYCLIC 122
|
||||
# define MPI_DISTRIBUTE_NONE 123
|
||||
# define MPI_DISTRIBUTE_DFLT_DARG -49767
|
||||
#endif
|
||||
|
||||
|
||||
/* MPI-IO function prototypes */
|
||||
|
||||
/* The compiler must support ANSI C style prototypes, otherwise
|
||||
long long constants (e.g. 0) may get passed as ints. */
|
||||
|
||||
#ifndef HAVE_PRAGMA_HP_SEC_DEF
|
||||
|
||||
/* Section 9.2 */
|
||||
/* Begin Prototypes */
|
||||
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) ROMIO_API_PUBLIC;
|
||||
int MPI_File_get_view(MPI_File fh, MPI_Offset *disp, MPI_Datatype *etype, MPI_Datatype *filetype,
|
||||
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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) ROMIO_API_PUBLIC;
|
||||
|
||||
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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) ROMIO_API_PUBLIC;
|
||||
|
||||
/* Section 9.6.1 */
|
||||
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) 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) 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) 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) 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) 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) 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) ROMIO_API_PUBLIC;
|
||||
#endif
|
||||
|
||||
/* 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
|
||||
should only happen if MPICH_RENAMING_MPI_FUNCS is not defined. */
|
||||
/* Section 4.12.4 */
|
||||
#if !defined(MPICH_RENAMING_MPI_FUNCS)
|
||||
#ifdef MPI_File_f2c
|
||||
#undef MPI_File_f2c
|
||||
#endif
|
||||
#ifdef MPI_File_c2f
|
||||
#undef MPI_File_c2f
|
||||
#endif
|
||||
#endif
|
||||
/* above needed for some versions of mpi.h in MPICH!! */
|
||||
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) 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[]) 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) 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[]) ROMIO_API_PUBLIC;
|
||||
int MPIO_Testsome(int incount, MPIO_Request array_of_requests[], int *outcount,
|
||||
int array_of_indices[], MPI_Status array_of_statuses[]) ROMIO_API_PUBLIC;
|
||||
|
||||
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) 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
|
||||
should only happen if MPICH_RENAMING_MPI_FUNCS is not defined. */
|
||||
#if !defined(MPICH_RENAMING_MPI_FUNCS)
|
||||
#ifdef MPI_Info_f2c
|
||||
#undef MPI_Info_f2c
|
||||
#endif
|
||||
#ifdef MPI_Info_c2f
|
||||
#undef MPI_Info_c2f
|
||||
#endif
|
||||
#endif
|
||||
/* above needed for some versions of mpi.h in MPICH!! */
|
||||
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 */
|
||||
|
||||
|
||||
/**************** BINDINGS FOR THE PROFILING INTERFACE ***************/
|
||||
|
||||
|
||||
/* Section 9.2 */
|
||||
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) ROMIO_API_PUBLIC;
|
||||
int PMPI_File_get_view(MPI_File, MPI_Offset *,
|
||||
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) 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) 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) 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) 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_at(MPI_File, MPI_Offset, void *,
|
||||
int, MPI_Datatype, MPIO_Request *)
|
||||
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) 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) ROMIO_API_PUBLIC;
|
||||
int PMPI_File_read_all(MPI_File, void *, int, MPI_Datatype, MPI_Status *)
|
||||
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) 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) 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) ROMIO_API_PUBLIC;
|
||||
int PMPI_File_iwrite(MPI_File, const void *, int, MPI_Datatype, MPIO_Request *)
|
||||
MPICH_ATTR_POINTER_WITH_TYPE_TAG(2,4) ROMIO_API_PUBLIC;
|
||||
|
||||
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) 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) ROMIO_API_PUBLIC;
|
||||
int PMPI_File_iread_shared(MPI_File, void *, int,
|
||||
MPI_Datatype, MPIO_Request *)
|
||||
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) ROMIO_API_PUBLIC;
|
||||
int PMPI_File_read_ordered(MPI_File, void *, int, MPI_Datatype, MPI_Status *)
|
||||
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) 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) 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) 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) 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) 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) 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) 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 *) 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 *) ROMIO_API_PUBLIC;
|
||||
|
||||
/* Section 9.6.1 */
|
||||
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 ) 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) 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) 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) 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) 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 *) ROMIO_API_PUBLIC;
|
||||
|
||||
/* Section 4.14.5 */
|
||||
int PMPI_Type_create_darray(int, int, int, int *, int *,
|
||||
int *, int *, int, MPI_Datatype, MPI_Datatype *) ROMIO_API_PUBLIC;
|
||||
#endif
|
||||
|
||||
/* Section 4.12.4 */
|
||||
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 *) 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 *) 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) ROMIO_API_PUBLIC;
|
||||
MPI_Info PMPI_Info_f2c(MPI_Fint) ROMIO_API_PUBLIC;
|
||||
#endif
|
||||
|
||||
#if defined(__cplusplus)
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
46
macx64/mpi/mpich/include/mpiof.h
Normal file
46
macx64/mpi/mpich/include/mpiof.h
Normal file
@@ -0,0 +1,46 @@
|
||||
!
|
||||
! Copyright (C) 1997 University of Chicago.
|
||||
! See COPYRIGHT notice in top-level directory.
|
||||
!
|
||||
!
|
||||
! user include file for Fortran MPI-IO programs
|
||||
!
|
||||
INTEGER MPI_MODE_RDONLY, MPI_MODE_RDWR, MPI_MODE_WRONLY
|
||||
INTEGER MPI_MODE_DELETE_ON_CLOSE, MPI_MODE_UNIQUE_OPEN
|
||||
INTEGER MPI_MODE_CREATE, MPI_MODE_EXCL
|
||||
INTEGER MPI_MODE_APPEND, MPI_MODE_SEQUENTIAL
|
||||
PARAMETER (MPI_MODE_RDONLY=2, MPI_MODE_RDWR=8, MPI_MODE_WRONLY=4)
|
||||
PARAMETER (MPI_MODE_CREATE=1, MPI_MODE_DELETE_ON_CLOSE=16)
|
||||
PARAMETER (MPI_MODE_UNIQUE_OPEN=32, MPI_MODE_EXCL=64)
|
||||
PARAMETER (MPI_MODE_APPEND=128, MPI_MODE_SEQUENTIAL=256)
|
||||
!
|
||||
INTEGER MPI_FILE_NULL
|
||||
PARAMETER (MPI_FILE_NULL=0)
|
||||
!
|
||||
INTEGER MPI_MAX_DATAREP_STRING
|
||||
PARAMETER (MPI_MAX_DATAREP_STRING=128)
|
||||
!
|
||||
INTEGER MPI_SEEK_SET, MPI_SEEK_CUR, MPI_SEEK_END
|
||||
PARAMETER (MPI_SEEK_SET=600, MPI_SEEK_CUR=602, MPI_SEEK_END=604)
|
||||
!
|
||||
INTEGER MPIO_REQUEST_NULL
|
||||
PARAMETER (MPIO_REQUEST_NULL=0)
|
||||
!
|
||||
integer*8 MPI_DISPLACEMENT_CURRENT
|
||||
PARAMETER (MPI_DISPLACEMENT_CURRENT=-54278278)
|
||||
!
|
||||
!
|
||||
!
|
||||
!
|
||||
!
|
||||
!
|
||||
!
|
||||
!
|
||||
!
|
||||
!
|
||||
!
|
||||
!
|
||||
!
|
||||
!
|
||||
!
|
||||
!
|
||||
BIN
macx64/mpi/mpich/lib/libmpi.12.dylib
Executable file
BIN
macx64/mpi/mpich/lib/libmpi.12.dylib
Executable file
Binary file not shown.
BIN
macx64/mpi/mpich/lib/libmpi.a
Normal file
BIN
macx64/mpi/mpich/lib/libmpi.a
Normal file
Binary file not shown.
1
macx64/mpi/mpich/lib/libmpi.dylib
Symbolic link
1
macx64/mpi/mpich/lib/libmpi.dylib
Symbolic link
@@ -0,0 +1 @@
|
||||
libmpi.12.dylib
|
||||
41
macx64/mpi/mpich/lib/libmpi.la
Executable file
41
macx64/mpi/mpich/lib/libmpi.la
Executable file
@@ -0,0 +1,41 @@
|
||||
# libmpi.la - a libtool library file
|
||||
# Generated by libtool (GNU libtool) 2.4.6
|
||||
#
|
||||
# Please DO NOT delete this file!
|
||||
# It is necessary for linking the library.
|
||||
|
||||
# The name that we can dlopen(3).
|
||||
dlname='libmpi.12.dylib'
|
||||
|
||||
# Names of this library.
|
||||
library_names='libmpi.12.dylib libmpi.dylib'
|
||||
|
||||
# The name of the static archive.
|
||||
old_library='libmpi.a'
|
||||
|
||||
# Linker flags that cannot go in dependency_libs.
|
||||
inherited_linker_flags=' -framework OpenCL'
|
||||
|
||||
# Libraries that this one depends upon.
|
||||
dependency_libs=' /Users/brgirgis/Documents/code/idiscovery/cpp-thirdparty-src/mpi/mpich/install/3.3.1/lib/libpmpi.la -lm -lpthread'
|
||||
|
||||
# Names of additional weak libraries provided by this library
|
||||
weak_library_names=''
|
||||
|
||||
# Version information for libmpi.
|
||||
current=13
|
||||
age=1
|
||||
revision=7
|
||||
|
||||
# Is this an already installed library?
|
||||
installed=yes
|
||||
|
||||
# Should we warn about portability when linking against -modules?
|
||||
shouldnotlink=no
|
||||
|
||||
# Files to dlopen/dlpreopen
|
||||
dlopen=''
|
||||
dlpreopen=''
|
||||
|
||||
# Directory that this library needs to be installed in:
|
||||
libdir='/Users/brgirgis/Documents/code/idiscovery/cpp-thirdparty-src/mpi/mpich/install/3.3.1/lib'
|
||||
1
macx64/mpi/mpich/lib/libmpich.dylib
Symbolic link
1
macx64/mpi/mpich/lib/libmpich.dylib
Symbolic link
@@ -0,0 +1 @@
|
||||
libmpi.dylib
|
||||
1
macx64/mpi/mpich/lib/libmpl.dylib
Symbolic link
1
macx64/mpi/mpich/lib/libmpl.dylib
Symbolic link
@@ -0,0 +1 @@
|
||||
libmpi.dylib
|
||||
1
macx64/mpi/mpich/lib/libopa.dylib
Symbolic link
1
macx64/mpi/mpich/lib/libopa.dylib
Symbolic link
@@ -0,0 +1 @@
|
||||
libmpi.dylib
|
||||
BIN
macx64/mpi/mpich/lib/libpmpi.12.dylib
Executable file
BIN
macx64/mpi/mpich/lib/libpmpi.12.dylib
Executable file
Binary file not shown.
BIN
macx64/mpi/mpich/lib/libpmpi.a
Normal file
BIN
macx64/mpi/mpich/lib/libpmpi.a
Normal file
Binary file not shown.
1
macx64/mpi/mpich/lib/libpmpi.dylib
Symbolic link
1
macx64/mpi/mpich/lib/libpmpi.dylib
Symbolic link
@@ -0,0 +1 @@
|
||||
libpmpi.12.dylib
|
||||
41
macx64/mpi/mpich/lib/libpmpi.la
Executable file
41
macx64/mpi/mpich/lib/libpmpi.la
Executable file
@@ -0,0 +1,41 @@
|
||||
# libpmpi.la - a libtool library file
|
||||
# Generated by libtool (GNU libtool) 2.4.6
|
||||
#
|
||||
# Please DO NOT delete this file!
|
||||
# It is necessary for linking the library.
|
||||
|
||||
# The name that we can dlopen(3).
|
||||
dlname='libpmpi.12.dylib'
|
||||
|
||||
# Names of this library.
|
||||
library_names='libpmpi.12.dylib libpmpi.dylib'
|
||||
|
||||
# The name of the static archive.
|
||||
old_library='libpmpi.a'
|
||||
|
||||
# Linker flags that cannot go in dependency_libs.
|
||||
inherited_linker_flags=' -framework OpenCL'
|
||||
|
||||
# Libraries that this one depends upon.
|
||||
dependency_libs=' -lm -lpthread'
|
||||
|
||||
# Names of additional weak libraries provided by this library
|
||||
weak_library_names=''
|
||||
|
||||
# Version information for libpmpi.
|
||||
current=13
|
||||
age=1
|
||||
revision=7
|
||||
|
||||
# Is this an already installed library?
|
||||
installed=yes
|
||||
|
||||
# Should we warn about portability when linking against -modules?
|
||||
shouldnotlink=no
|
||||
|
||||
# Files to dlopen/dlpreopen
|
||||
dlopen=''
|
||||
dlpreopen=''
|
||||
|
||||
# Directory that this library needs to be installed in:
|
||||
libdir='/Users/brgirgis/Documents/code/idiscovery/cpp-thirdparty-src/mpi/mpich/install/3.3.1/lib'
|
||||
20
macx64/mpi/mpich/lib/pkgconfig/mpich.pc
Normal file
20
macx64/mpi/mpich/lib/pkgconfig/mpich.pc
Normal file
@@ -0,0 +1,20 @@
|
||||
# this gives access to the mpich header files
|
||||
prefix=/Users/brgirgis/Documents/code/idiscovery/cpp-thirdparty-src/mpi/mpich/install/3.3.1
|
||||
exec_prefix=${prefix}
|
||||
libdir=${exec_prefix}/lib
|
||||
includedir=${prefix}/include
|
||||
|
||||
Name: mpich
|
||||
Description: High Performance and portable MPI
|
||||
Version: 3.3.1
|
||||
URL: http://www.mcs.anl.gov/research/projects/mpich
|
||||
Requires:
|
||||
Libs: -Wl,-flat_namespace -L${libdir} -lmpi -lpmpi -lm -lpthread
|
||||
Cflags: -I${includedir}
|
||||
|
||||
# pkg-config does not understand Cxxflags, etc. So we allow users to
|
||||
# query them using the --variable option
|
||||
|
||||
cxxflags= -I${includedir}
|
||||
fflags= -I${includedir}
|
||||
fcflags= -I${includedir}
|
||||
15
macx64/mpi/mpich/lib/pkgconfig/openpa.pc
Normal file
15
macx64/mpi/mpich/lib/pkgconfig/openpa.pc
Normal file
@@ -0,0 +1,15 @@
|
||||
prefix=/Users/brgirgis/Documents/code/idiscovery/cpp-thirdparty-src/mpi/mpich/install/3.3.1
|
||||
exec_prefix=${prefix}
|
||||
libdir=${exec_prefix}/lib
|
||||
includedir=${prefix}/include
|
||||
|
||||
# Technically, the -lopa below isn't needed if you are only using the atomic
|
||||
# primitives (not the queue code) and you are not using mutex emulation.
|
||||
|
||||
Name: OpenPA
|
||||
Description: Portable library for atomic operations
|
||||
Version: 1.0.3
|
||||
Libs: -L${libdir} -lopa
|
||||
Libs.private: -lpthread
|
||||
Cflags: -I${includedir}
|
||||
|
||||
563
macx64/mpi/mpich/share/doc/mpich/index.html
Normal file
563
macx64/mpi/mpich/share/doc/mpich/index.html
Normal file
@@ -0,0 +1,563 @@
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<TITLE>Web pages for MPI</TITLE>
|
||||
<!-- This file generated by createhtmlindex on -->
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<H1>Web pages for MPI</H1>
|
||||
<H2>MPI Commands</H2>
|
||||
<TABLE>
|
||||
<TR><TD><A HREF="www1/mpicc.html">mpicc</A></TD>
|
||||
<TD><A HREF="www1/mpiexec.html">mpiexec</A></TD>
|
||||
<TD><A HREF="www1/mpifort.html">mpifort</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="www1/mpicxx.html">mpicxx</A></TD>
|
||||
<TD><A HREF="www1/mpif77.html">mpif77</A></TD>
|
||||
<TD></TD>
|
||||
</TR>
|
||||
</TABLE>
|
||||
<H2>MPI Routines and Constants</H2>
|
||||
<TABLE>
|
||||
<TR><TD><A HREF="www3/Constants.html">Constants</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/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/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/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/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/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/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/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/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/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/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/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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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.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_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_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_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_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_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_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_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>
|
||||
BIN
macx64/mpi/mpich/share/doc/mpich/install.pdf
Normal file
BIN
macx64/mpi/mpich/share/doc/mpich/install.pdf
Normal file
Binary file not shown.
BIN
macx64/mpi/mpich/share/doc/mpich/logging.pdf
Normal file
BIN
macx64/mpi/mpich/share/doc/mpich/logging.pdf
Normal file
Binary file not shown.
BIN
macx64/mpi/mpich/share/doc/mpich/user.pdf
Normal file
BIN
macx64/mpi/mpich/share/doc/mpich/user.pdf
Normal file
Binary file not shown.
19
macx64/mpi/mpich/share/doc/mpich/www1/index.htm
Normal file
19
macx64/mpi/mpich/share/doc/mpich/www1/index.htm
Normal file
@@ -0,0 +1,19 @@
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<TITLE>Manpages for MPICH</TITLE>
|
||||
<!-- This file generated by createhtmlindex on -->
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<H1>Manpages for MPICH</H1>
|
||||
<TABLE>
|
||||
<TR><TD><A HREF="mpicc.html">mpicc</A></TD>
|
||||
<TD><A HREF="mpiexec.html">mpiexec</A></TD>
|
||||
<TD><A HREF="mpifort.html">mpifort</A></TD>
|
||||
</TR>
|
||||
<TR><TD><A HREF="mpicxx.html">mpicxx</A></TD>
|
||||
<TD><A HREF="mpif77.html">mpif77</A></TD>
|
||||
<TD></TD>
|
||||
</TR>
|
||||
</TABLE>
|
||||
</BODY>
|
||||
</HTML>
|
||||
137
macx64/mpi/mpich/share/doc/mpich/www1/mpicc.html
Normal file
137
macx64/mpi/mpich/share/doc/mpich/www1/mpicc.html
Normal file
@@ -0,0 +1,137 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>mpicc</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="mpicc"><H1>mpicc</H1></A>
|
||||
Compiles and links MPI programs written in C
|
||||
<H2>Description</H2>
|
||||
This command can be used to compile and link MPI programs written in
|
||||
C. It provides the options and any special libraries that are
|
||||
needed to compile and link MPI programs.
|
||||
<P>
|
||||
It is important to use this command, particularly when linking programs,
|
||||
as it provides the necessary libraries.
|
||||
<P>
|
||||
<H2>Command line arguments</H2>
|
||||
<DL>
|
||||
<DT><B>-show </B><DD>Show the commands that would be used without
|
||||
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
|
||||
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
|
||||
multiple compilers.
|
||||
|
||||
<DT><B>-compile_info </B><DD>Show the steps for compiling a program. This option
|
||||
can be used to see what options and include paths are
|
||||
used by mpicc.
|
||||
|
||||
<DT><B>-link_info </B><DD>Show the steps for linking a program. This option
|
||||
can be used to see what options and libraries are used by
|
||||
mpicc.
|
||||
|
||||
<DT><B>-profile=name </B><DD>Use the MPI profiling given by name. See below for
|
||||
details
|
||||
|
||||
<DT><B>-echo </B><DD>Show exactly what this program is doing.
|
||||
This option should normally not be used.
|
||||
|
||||
<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
|
||||
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
|
||||
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
|
||||
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
|
||||
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
|
||||
<PRE>
|
||||
mpicc -c foo.c
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
To link the output and make an executable, use
|
||||
<PRE>
|
||||
mpicc -o foo foo.o
|
||||
</PRE>
|
||||
|
||||
Combining compilation and linking in a single command
|
||||
<PRE>
|
||||
mpicc -o foo foo.c
|
||||
</PRE>
|
||||
|
||||
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:
|
||||
<P>
|
||||
<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
|
||||
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
|
||||
is read and may define the following variables:
|
||||
<DL>
|
||||
<DT><B>PROFILE_PRELIB </B><DD>Libraries (and paths) to include before the MPI library
|
||||
|
||||
<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
|
||||
</DL>
|
||||
<P>
|
||||
<PRE>
|
||||
PROFILE_PRELIB="-L/usr/local/myprof/lib -lmyprof"
|
||||
PROFILE_INCPATHS="-I/usr/local/myprof/include"
|
||||
</PRE>
|
||||
|
||||
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
|
||||
definitions to be added to the relevant compile commands.
|
||||
<P>
|
||||
<H2>See Also</H2>
|
||||
mpicxx, mpifort, mpiexec
|
||||
<BR>
|
||||
</BODY></HTML>
|
||||
137
macx64/mpi/mpich/share/doc/mpich/www1/mpicxx.html
Normal file
137
macx64/mpi/mpich/share/doc/mpich/www1/mpicxx.html
Normal file
@@ -0,0 +1,137 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>mpicxx</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="mpicxx"><H1>mpicxx</H1></A>
|
||||
Compiles and links MPI programs written in C++
|
||||
<H2>Description</H2>
|
||||
This command can be used to compile and link MPI programs written in
|
||||
C++. It provides the options and any special libraries that are
|
||||
needed to compile and link MPI programs.
|
||||
<P>
|
||||
It is important to use this command, particularly when linking programs,
|
||||
as it provides the necessary libraries.
|
||||
<P>
|
||||
<H2>Command line arguments</H2>
|
||||
<DL>
|
||||
<DT><B>-show </B><DD>Show the commands that would be used without
|
||||
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
|
||||
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
|
||||
multiple compilers.
|
||||
|
||||
<DT><B>-compile_info </B><DD>Show the steps for compiling a program. This option
|
||||
can be used to see what options and include paths are
|
||||
used by mpicxx.
|
||||
|
||||
<DT><B>-link_info </B><DD>Show the steps for linking a program. This option
|
||||
can be used to see what options and libraries are used by
|
||||
mpicxx.
|
||||
|
||||
<DT><B>-profile=name </B><DD>Use the MPI profiling given by name. See below for
|
||||
details
|
||||
|
||||
<DT><B>-echo </B><DD>Show exactly what this program is doing.
|
||||
This option should normally not be used.
|
||||
|
||||
<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
|
||||
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
|
||||
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
|
||||
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
|
||||
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
|
||||
<PRE>
|
||||
mpicxx -c foo.cxx
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
To link the output and make an executable, use
|
||||
<PRE>
|
||||
mpicxx -o foo foo.o
|
||||
</PRE>
|
||||
|
||||
Combining compilation and linking in a single command
|
||||
<PRE>
|
||||
mpicxx -o foo foo.cxx
|
||||
</PRE>
|
||||
|
||||
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:
|
||||
<P>
|
||||
<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
|
||||
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
|
||||
is read and may define the following variables:
|
||||
<DL>
|
||||
<DT><B>PROFILE_PRELIB </B><DD>Libraries (and paths) to include before the MPI library
|
||||
|
||||
<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
|
||||
</DL>
|
||||
<P>
|
||||
<PRE>
|
||||
PROFILE_PRELIB="-L/usr/local/myprof/lib -lmyprof"
|
||||
PROFILE_INCPATHS="-I/usr/local/myprof/include"
|
||||
</PRE>
|
||||
|
||||
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
|
||||
definitions to be added to the relevant compile commands.
|
||||
<P>
|
||||
<H2>See Also</H2>
|
||||
mpicc, mpifort, mpiexec
|
||||
<BR>
|
||||
</BODY></HTML>
|
||||
152
macx64/mpi/mpich/share/doc/mpich/www1/mpiexec.html
Normal file
152
macx64/mpi/mpich/share/doc/mpich/www1/mpiexec.html
Normal file
@@ -0,0 +1,152 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>mpiexec</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="mpiexec"><H1>mpiexec</H1></A>
|
||||
Run an MPI program
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
</PRE>
|
||||
<PRE>
|
||||
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
|
||||
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:
|
||||
<PRE>
|
||||
mpiexec -n 4 a.out
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
The MPI standard specifies the following arguments and their meanings:
|
||||
<P>
|
||||
<DL>
|
||||
<DT><B>-n <np> </B><DD>Specify the number of processes to use
|
||||
|
||||
<DT><B>-host <hostname> </B><DD>Name of host on which to run processes
|
||||
|
||||
<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>-path <pathlist> </B><DD>use this to find the executable
|
||||
|
||||
<DT><B>-soft <triplets> </B><DD>comma separated triplets that specify requested numbers
|
||||
of processes (see the MPI-2 specification for more details)
|
||||
|
||||
<DT><B>-file <name> </B><DD>implementation-defined specification file
|
||||
|
||||
<DT><B>-configfile <name> </B><DD>file containing specifications of host/program,
|
||||
one per line, with # as a comment indicator, e.g., the usual
|
||||
mpiexec input, but with ":" replaced with a newline. That is,
|
||||
the configfile contains lines with -soft, -n etc.
|
||||
</DL>
|
||||
<P>
|
||||
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
|
||||
processes on the same system on which it is running; in that case, the
|
||||
<TT>\-arch</TT> and <TT>\-host</TT> options are ignored.
|
||||
<P>
|
||||
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:
|
||||
<P>
|
||||
<PRE>
|
||||
mpiexec -n 4 ocean : -n 8 air
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
<P>
|
||||
<H2>MPICH-Specific Arguments</H2>
|
||||
<P>
|
||||
Many of the implementations of process managers in MPICH support the
|
||||
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>-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>.
|
||||
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>.
|
||||
|
||||
<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>-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>.
|
||||
|
||||
<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>-exitinfo </B><DD>Provide more information on the reason each process exited if
|
||||
there is an abnormal exit
|
||||
</DL>
|
||||
<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,
|
||||
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
|
||||
terminate MPI programs that take longer than the value specified by
|
||||
<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
|
||||
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>.
|
||||
|
||||
<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
|
||||
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
|
||||
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>).
|
||||
|
||||
<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>.
|
||||
<P>
|
||||
</BODY></HTML>
|
||||
132
macx64/mpi/mpich/share/doc/mpich/www1/mpif77.html
Normal file
132
macx64/mpi/mpich/share/doc/mpich/www1/mpif77.html
Normal file
@@ -0,0 +1,132 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>mpif77</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="mpif77"><H1>mpif77</H1></A>
|
||||
Compiles and links MPI programs written in Fortran 77
|
||||
<H2>Description</H2>
|
||||
This command can be used to compile and link MPI programs written in
|
||||
Fortran. It provides the options and any special libraries that are
|
||||
needed to compile and link MPI programs.
|
||||
<P>
|
||||
It is important to use this command, particularly when linking programs,
|
||||
as it provides the necessary libraries.
|
||||
<P>
|
||||
<H2>Command line arguments</H2>
|
||||
<DL>
|
||||
<DT><B>-show </B><DD>Show the commands that would be used without
|
||||
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
|
||||
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
|
||||
multiple compilers.
|
||||
|
||||
<DT><B>-compile_info </B><DD>Show the steps for compiling a program. This option
|
||||
can be used to see what options and include paths are
|
||||
used by mpif77.
|
||||
|
||||
<DT><B>-link_info </B><DD>Show the steps for linking a program. This option
|
||||
can be used to see what options and libraries are used by
|
||||
mpif77.
|
||||
|
||||
<DT><B>-profile=name </B><DD>Use the MPI profiling given by name. See below for
|
||||
details
|
||||
|
||||
<DT><B>-echo </B><DD>Show exactly what this program is doing.
|
||||
This option should normally not be used.
|
||||
|
||||
<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
|
||||
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
|
||||
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
|
||||
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
|
||||
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
|
||||
<PRE>
|
||||
mpif77 -c foo.f
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
To link the output and make an executable, use
|
||||
<PRE>
|
||||
mpif77 -o foo foo.o
|
||||
</PRE>
|
||||
|
||||
Combining compilation and linking in a single command
|
||||
<PRE>
|
||||
mpif77 -o foo foo.f
|
||||
</PRE>
|
||||
|
||||
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:
|
||||
<P>
|
||||
<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
|
||||
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
|
||||
is read and may define the following variables:
|
||||
<DL>
|
||||
<DT><B>PROFILE_PRELIB </B><DD>Libraries (and paths) to include before the MPI library
|
||||
|
||||
<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
|
||||
</DL>
|
||||
<P>
|
||||
<PRE>
|
||||
PROFILE_PRELIB="-L/usr/local/myprof/lib -lmyprof"
|
||||
PROFILE_INCPATHS="-I/usr/local/myprof/include"
|
||||
</PRE>
|
||||
|
||||
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
|
||||
definitions to be added to the relevant compile commands.
|
||||
<P>
|
||||
<H2>See Also</H2>
|
||||
mpicc, mpicxx, mpifort, mpiexec
|
||||
<BR>
|
||||
</BODY></HTML>
|
||||
132
macx64/mpi/mpich/share/doc/mpich/www1/mpifort.html
Normal file
132
macx64/mpi/mpich/share/doc/mpich/www1/mpifort.html
Normal file
@@ -0,0 +1,132 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>mpifort</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="mpifort"><H1>mpifort</H1></A>
|
||||
Compiles and links MPI programs written in Fortran 90
|
||||
<H2>Description</H2>
|
||||
This command can be used to compile and link MPI programs written in
|
||||
Fortran. It provides the options and any special libraries that are
|
||||
needed to compile and link MPI programs.
|
||||
<P>
|
||||
It is important to use this command, particularly when linking programs,
|
||||
as it provides the necessary libraries.
|
||||
<P>
|
||||
<H2>Command line arguments</H2>
|
||||
<DL>
|
||||
<DT><B>-show </B><DD>Show the commands that would be used without
|
||||
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
|
||||
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
|
||||
multiple compilers.
|
||||
|
||||
<DT><B>-compile_info </B><DD>Show the steps for compiling a program. This option
|
||||
can be used to see what options and include paths are
|
||||
used by mpifort.
|
||||
|
||||
<DT><B>-link_info </B><DD>Show the steps for linking a program. This option
|
||||
can be used to see what options and libraries are used by
|
||||
mpifort.
|
||||
|
||||
<DT><B>-profile=name </B><DD>Use the MPI profiling given by name. See below for
|
||||
details
|
||||
|
||||
<DT><B>-echo </B><DD>Show exactly what this program is doing.
|
||||
This option should normally not be used.
|
||||
|
||||
<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
|
||||
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
|
||||
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
|
||||
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
|
||||
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
|
||||
<PRE>
|
||||
mpifort -c foo.f
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
To link the output and make an executable, use
|
||||
<PRE>
|
||||
mpifort -o foo foo.o
|
||||
</PRE>
|
||||
|
||||
Combining compilation and linking in a single command
|
||||
<PRE>
|
||||
mpifort -o foo foo.f
|
||||
</PRE>
|
||||
|
||||
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:
|
||||
<P>
|
||||
<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
|
||||
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
|
||||
is read and may define the following variables:
|
||||
<DL>
|
||||
<DT><B>PROFILE_PRELIB </B><DD>Libraries (and paths) to include before the MPI library
|
||||
|
||||
<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
|
||||
</DL>
|
||||
<P>
|
||||
<PRE>
|
||||
PROFILE_PRELIB="-L/usr/local/myprof/lib -lmyprof"
|
||||
PROFILE_INCPATHS="-I/usr/local/myprof/include"
|
||||
</PRE>
|
||||
|
||||
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
|
||||
definitions to be added to the relevant compile commands.
|
||||
<P>
|
||||
<H2>See Also</H2>
|
||||
mpicc, mpicxx, mpifort, mpiexec
|
||||
<BR>
|
||||
</BODY></HTML>
|
||||
891
macx64/mpi/mpich/share/doc/mpich/www3/Constants.html
Normal file
891
macx64/mpi/mpich/share/doc/mpich/www3/Constants.html
Normal file
@@ -0,0 +1,891 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>Constants</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="Constants"><H1>Constants</H1></A>
|
||||
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
|
||||
<P>
|
||||
<H2>C datatypes</H2>
|
||||
MPI_CHAR - char
|
||||
<DL><DT><B>MPI_SIGNED_CHAR </B> <DD> signed char
|
||||
</DL>
|
||||
<DL><DT><B>MPI_UNSIGNED_CHAR </B> <DD> unsigned char
|
||||
</DL>
|
||||
<DL><DT><B>MPI_BYTE </B> <DD> See standard; like unsigned char
|
||||
</DL>
|
||||
<DL><DT><B>MPI_WCHAR </B> <DD> wide character (wchar_t)
|
||||
</DL>
|
||||
<DL><DT><B>MPI_SHORT </B> <DD> short
|
||||
</DL>
|
||||
<DL><DT><B>MPI_UNSIGNED_SHORT </B> <DD> unsigned short
|
||||
</DL>
|
||||
<DL><DT><B>MPI_INT </B> <DD> int
|
||||
</DL>
|
||||
<DL><DT><B>MPI_UNSIGNED </B> <DD> unsigned int
|
||||
</DL>
|
||||
<DL><DT><B>MPI_LONG </B> <DD> long
|
||||
</DL>
|
||||
<DL><DT><B>MPI_UNSIGNED_LONG </B> <DD> unsigned long
|
||||
</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>
|
||||
<DL><DT><B>MPI_UNSIGNED_LONG_LONG </B> <DD> unsigned long long
|
||||
</DL>
|
||||
<DL><DT><B>MPI_FLOAT </B> <DD> float
|
||||
</DL>
|
||||
<DL><DT><B>MPI_DOUBLE </B> <DD> double
|
||||
</DL>
|
||||
<DL><DT><B>MPI_LONG_DOUBLE </B> <DD> long double (some systems may not implement this)
|
||||
</DL>
|
||||
<DL><DT><B>MPI_INT8_T </B> <DD> int8_t
|
||||
</DL>
|
||||
<DL><DT><B>MPI_INT16_T </B> <DD> int16_t
|
||||
</DL>
|
||||
<DL><DT><B>MPI_INT32_T </B> <DD> int32_t
|
||||
</DL>
|
||||
<DL><DT><B>MPI_INT64_T </B> <DD> int64_t
|
||||
</DL>
|
||||
<DL><DT><B>MPI_UINT8_T </B> <DD> uint8_t
|
||||
</DL>
|
||||
<DL><DT><B>MPI_UINT16_T </B> <DD> uint16_t
|
||||
</DL>
|
||||
<DL><DT><B>MPI_UINT32_T </B> <DD> uint32_t
|
||||
</DL>
|
||||
<DL><DT><B>MPI_UINT64_T </B> <DD> uint64_t
|
||||
</DL>
|
||||
<DL><DT><B>MPI_C_BOOL </B> <DD> _Bool
|
||||
</DL>
|
||||
<DL><DT><B>MPI_C_FLOAT_COMPLEX </B> <DD> float _Complex
|
||||
</DL>
|
||||
<DL><DT><B>MPI_C_COMPLEX </B> <DD> float _Complex
|
||||
</DL>
|
||||
<DL><DT><B>MPI_C_DOUBLE_COMPLEX </B> <DD> double _Complex
|
||||
</DL>
|
||||
<DL><DT><B>MPI_C_LONG_DOUBLE_COMPLEX </B> <DD> long double _Complex
|
||||
</DL>
|
||||
</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>
|
||||
</DL>
|
||||
<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>
|
||||
<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>
|
||||
</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
|
||||
</DL>
|
||||
<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>
|
||||
</DL>
|
||||
<DL><DT><B>MPI_LOGICAL </B> <DD> <TT>LOGICAL
|
||||
</TT>
|
||||
</DL>
|
||||
<DL><DT><B>MPI_DOUBLE_PRECISION </B> <DD> <TT>DOUBLE PRECISION
|
||||
</TT>
|
||||
</DL>
|
||||
<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>
|
||||
</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
|
||||
</DL>
|
||||
<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>
|
||||
<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>
|
||||
<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>
|
||||
<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>
|
||||
<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
|
||||
two elements of the same Fortran type.
|
||||
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>
|
||||
</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>
|
||||
</DL>
|
||||
<DL><DT><B>MPI_COUNT </B> <DD> Datatype for an <TT>MPI_Count
|
||||
</TT>
|
||||
</DL>
|
||||
</DL>
|
||||
<P>
|
||||
<H2>MPI Datatype Combiner Names</H2>
|
||||
MPI_COMBINER_NAMED - a named predefined datatype
|
||||
<DL><DT><B>MPI_COMBINER_DUP </B> <DD> MPI_TYPE_DUP
|
||||
</DL>
|
||||
<DL><DT><B>MPI_COMBINER_CONTIGUOUS </B> <DD> MPI_TYPE_CONTIGUOUS
|
||||
</DL>
|
||||
<DL><DT><B>MPI_COMBINER_VECTOR </B> <DD> MPI_TYPE_VECTOR
|
||||
</DL>
|
||||
<DL><DT><B>MPI_COMBINER_HVECTOR_INTEGER </B> <DD> Removed in MPI-3
|
||||
</DL>
|
||||
<DL><DT><B>MPI_COMBINER_HVECTOR </B> <DD> MPI_TYPE_CREATE_HVECTOR
|
||||
</DL>
|
||||
<DL><DT><B>MPI_COMBINER_INDEXED </B> <DD> MPI_TYPE_INDEXED
|
||||
</DL>
|
||||
<DL><DT><B>MPI_COMBINER_HINDEXED_INTEGER </B> <DD> Removed in MPI-3
|
||||
</DL>
|
||||
<DL><DT><B>MPI_COMBINER_HINDEXED </B> <DD> MPI_TYPE_CREATE_HINDEXED
|
||||
</DL>
|
||||
<DL><DT><B>MPI_COMBINER_INDEXED_BLOCK </B> <DD> MPI_TYPE_CREATE_INDEXED_BLOCK
|
||||
</DL>
|
||||
<DL><DT><B>MPI_COMBINER_STRUCT_INTEGER </B> <DD> Removed in MPI-3
|
||||
</DL>
|
||||
<DL><DT><B>MPI_COMBINER_STRUCT </B> <DD> MPI_TYPE_CREATE_STRUCT
|
||||
</DL>
|
||||
<DL><DT><B>MPI_COMBINER_SUBARRAY </B> <DD> MPI_TYPE_CREATE_SUBARRAY
|
||||
</DL>
|
||||
<DL><DT><B>MPI_COMBINER_DARRAY </B> <DD> MPI_TYPE_CREATE_DARRAY
|
||||
</DL>
|
||||
<DL><DT><B>MPI_COMBINER_F90_REAL </B> <DD> MPI_TYPE_CREATE_F90_REAL
|
||||
</DL>
|
||||
<DL><DT><B>MPI_COMBINER_F90_COMPLEX </B> <DD> MPI_TYPE_CREATE_F90_COMPLEX
|
||||
</DL>
|
||||
<DL><DT><B>MPI_COMBINER_F90_INTEGER </B> <DD> MPI_TYPE_CREATE_F90_INTEGER
|
||||
</DL>
|
||||
<DL><DT><B>MPI_COMBINER_RESIZED </B> <DD> MPI_TYPE_CREATE_RESIZED
|
||||
</DL>
|
||||
<DL><DT><B>MPI_COMBINER_HINDEXED_BLOCK </B> <DD> MPI_TYPE_CREATE_HINDEXED_BLOCK
|
||||
</DL>
|
||||
</DL>
|
||||
<P>
|
||||
<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>
|
||||
</DL>
|
||||
<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.
|
||||
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>
|
||||
<DL><DT><B>MPI_DISTRIBUTE_BLOCK </B> <DD> Block distribution
|
||||
</DL>
|
||||
<DL><DT><B>MPI_DISTRIBUTE_CYCLIC </B> <DD> Cyclic distribution
|
||||
</DL>
|
||||
<DL><DT><B>MPI_DISTRIBUTE_NONE </B> <DD> This dimension is not distributed
|
||||
</DL>
|
||||
<DL><DT><B>MPI_DISTRIBUTE_DFLT_DARG </B> <DD> Use the default distribution
|
||||
</DL>
|
||||
</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
|
||||
MPI_COMM_WORLD - Contains all of the processes
|
||||
<DL><DT><B>MPI_COMM_SELF </B> <DD> Contains only the calling process
|
||||
</DL>
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Kind of communicator for 'MPI_COMM_SPLIT_TYPE'</H2>
|
||||
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
|
||||
<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>
|
||||
<DL><DT><B>MPI_SIMILAR </B> <DD> Same members, but in a different order
|
||||
</DL>
|
||||
<DL><DT><B>MPI_UNEQUAL </B> <DD> Different
|
||||
</DL>
|
||||
</DL>
|
||||
<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 predefined operations are
|
||||
<P>
|
||||
MPI_MAX - return the maximum
|
||||
<DL><DT><B>MPI_MIN </B> <DD> return the minumum
|
||||
</DL>
|
||||
<DL><DT><B>MPI_SUM </B> <DD> return the sum
|
||||
</DL>
|
||||
<DL><DT><B>MPI_PROD </B> <DD> return the product
|
||||
</DL>
|
||||
<DL><DT><B>MPI_LAND </B> <DD> return the logical and
|
||||
</DL>
|
||||
<DL><DT><B>MPI_BAND </B> <DD> return the bitwise and
|
||||
</DL>
|
||||
<DL><DT><B>MPI_LOR </B> <DD> return the logical or
|
||||
</DL>
|
||||
<DL><DT><B>MPI_BOR </B> <DD> return the bitwise of
|
||||
</DL>
|
||||
<DL><DT><B>MPI_LXOR </B> <DD> return the logical exclusive or
|
||||
</DL>
|
||||
<DL><DT><B>MPI_BXOR </B> <DD> return the bitwise exclusive or
|
||||
</DL>
|
||||
<DL><DT><B>MPI_MINLOC </B> <DD> return the minimum and the location (actually, the value of
|
||||
the second element of the structure where the minimum of
|
||||
the first is found)
|
||||
</DL>
|
||||
<DL><DT><B>MPI_MAXLOC </B> <DD> return the maximum and the location
|
||||
</DL>
|
||||
<DL><DT><B>MPI_REPLACE </B> <DD> replace b with a
|
||||
</DL>
|
||||
<DL><DT><B>MPI_NO_OP </B> <DD> perform no operation
|
||||
</DL>
|
||||
</DL>
|
||||
<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>,
|
||||
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.
|
||||
<P>
|
||||
<H2>Permanent key values</H2>
|
||||
These are the same in C and Fortran
|
||||
<P>
|
||||
MPI_TAG_UB - Largest tag value
|
||||
<DL><DT><B>MPI_HOST </B> <DD> Rank of process that is host, if any
|
||||
</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>
|
||||
<DL><DT><B>MPI_UNIVERSE_SIZE </B> <DD> Number of available processes. See the standard for
|
||||
a description of limitations on this value
|
||||
</DL>
|
||||
<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
|
||||
</DL>
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Null objects</H2>
|
||||
MPI_COMM_NULL - Null communicator
|
||||
<DL><DT><B>MPI_OP_NULL </B> <DD> Null operation
|
||||
</DL>
|
||||
<DL><DT><B>MPI_GROUP_NULL </B> <DD> Null group
|
||||
</DL>
|
||||
<DL><DT><B>MPI_DATATYPE_NULL </B> <DD> Null datatype
|
||||
</DL>
|
||||
<DL><DT><B>MPI_REQUEST_NULL </B> <DD> Null request
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERRHANDLER_NULL </B> <DD> Null error handler
|
||||
</DL>
|
||||
<DL><DT><B>MPI_WIN_NULL </B> <DD> Null window handle
|
||||
</DL>
|
||||
<DL><DT><B>MPI_FILE_NULL </B> <DD> Null file handle
|
||||
</DL>
|
||||
<DL><DT><B>MPI_INFO_NULL </B> <DD> Null info handle
|
||||
</DL>
|
||||
<DL><DT><B>MPI_MESSAGE_NULL </B> <DD> Null message handle
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ARGV_NULL </B> <DD> Empty ARGV value for spawn commands
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ARGVS_NULL </B> <DD> Empty ARGV array for spawn-multiple command
|
||||
</DL>
|
||||
<DL><DT><B>MPI_T_ENUM_NULL </B> <DD> Null MPI_T enum
|
||||
</DL>
|
||||
<DL><DT><B>MPI_T_CVAR_HANDLE_NULL </B> <DD> Null MPI_T control variable handle
|
||||
</DL>
|
||||
<DL><DT><B>MPI_T_PVAR_HANDLE_NULL </B> <DD> Null MPI_T performance variable handle
|
||||
</DL>
|
||||
<DL><DT><B>MPI_T_PVAR_SESSION_NULL</B> <DD> Null MPI_T performance variable session handle
|
||||
</DL>
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Predefined Constants</H2>
|
||||
MPI_MAX_PROCESSOR_NAME - Maximum length of name returned by
|
||||
<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>
|
||||
</DL>
|
||||
<DL><DT><B>MPI_MAX_LIBRARY_VERSION_STRING </B> <DD> Maximum length of string returned by
|
||||
<TT>MPI_GET_LIBRARY_VERSION_STRING</TT>???
|
||||
</DL>
|
||||
<DL><DT><B>MPI_MAX_PORT_NAME </B> <DD> Maximum length of a port
|
||||
</DL>
|
||||
<DL><DT><B>MPI_MAX_OBJECT_NAME </B> <DD> Maximum length of an object (?)
|
||||
</DL>
|
||||
<DL><DT><B>MPI_MAX_INFO_KEY </B> <DD> Maximum length of an info key
|
||||
</DL>
|
||||
<DL><DT><B>MPI_MAX_INFO_VAL </B> <DD> Maximum length of an info value
|
||||
</DL>
|
||||
<DL><DT><B>MPI_UNDEFINED </B> <DD> Used by many routines to indicated
|
||||
undefined or unknown integer value
|
||||
</DL>
|
||||
<DL><DT><B>MPI_UNDEFINED_RANK </B> <DD> Unknown rank
|
||||
</DL>
|
||||
<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>
|
||||
<DL><DT><B>MPI_PROC_NULL </B> <DD> This rank may be used to send or receive from no-one.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ANY_SOURCE </B> <DD> In a receive, accept a message from anyone.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ANY_TAG </B> <DD> In a receive, accept a message with any tag value.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_BOTTOM </B> <DD> May be used to indicate the bottom of the address space
|
||||
</DL>
|
||||
<DL><DT><B>MPI_IN_PLACE </B> <DD> Special location for buffer in some
|
||||
collective communication routines
|
||||
</DL>
|
||||
<DL><DT><B>MPI_VERSION </B> <DD> Numeric value of MPI version (e.g., 3)
|
||||
</DL>
|
||||
<DL><DT><B>MPI_SUBVERSION </B> <DD> Numeric value of MPI subversion (e.g., 1)
|
||||
</DL>
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Topology types</H2>
|
||||
MPI_CART - Cartesian grid
|
||||
<DL><DT><B>MPI_GRAPH </B> <DD> General graph
|
||||
</DL>
|
||||
<DL><DT><B>MPI_DIST_GRAPH </B> <DD> General distributed graph
|
||||
</DL>
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Special values for distributed graph</H2>
|
||||
MPI_UNWEIGHTED - Indicates that the edges are unweighted
|
||||
<DL><DT><B>MPI_WEIGHTS_EMPTY </B> <DD> Special address that indicates no array of weights
|
||||
information
|
||||
</DL>
|
||||
</DL>
|
||||
<P>
|
||||
<H2>File Modes</H2>
|
||||
MPI_MODE_RDONLY - Read only
|
||||
<DL><DT><B>MPI_MODE_RDWR </B> <DD> Read and write
|
||||
</DL>
|
||||
<DL><DT><B>MPI_MODE_WRONLY </B> <DD> Write only
|
||||
</DL>
|
||||
<DL><DT><B>MPI_MODE_CREATE </B> <DD> Create the file if it does not exist
|
||||
</DL>
|
||||
<DL><DT><B>MPI_MODE_EXCL </B> <DD> It is an error if creating a file that already
|
||||
exists
|
||||
</DL>
|
||||
<DL><DT><B>MPI_MODE_DELETE_ON_CLOSE </B> <DD> Delete the file on close
|
||||
</DL>
|
||||
<DL><DT><B>MPI_MODE_UNIQUE_OPEN </B> <DD> The file will not be concurrently opened elsewhere
|
||||
</DL>
|
||||
<DL><DT><B>MPI_MODE_APPEND </B> <DD> The initial position of all file pointers is at
|
||||
the end of the file
|
||||
</DL>
|
||||
<DL><DT><B>MPI_MODE_SEQUENTIAL </B> <DD> File will only be accessed sequentially
|
||||
</DL>
|
||||
</DL>
|
||||
<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>
|
||||
<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>
|
||||
</DL>
|
||||
<DL><DT><B>MPI_SEEK_END </B> <DD> Set the pointer to the end of the file plus <TT>offset
|
||||
</TT>
|
||||
</DL>
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Window attributes</H2>
|
||||
MPI_WIN_BASE - window base address.
|
||||
<DL><DT><B>MPI_WIN_SIZE </B> <DD> window size, in bytes
|
||||
</DL>
|
||||
<DL><DT><B>MPI_WIN_DISP_UNIT </B> <DD> displacement unit associated with the window
|
||||
</DL>
|
||||
<DL><DT><B>MPI_WIN_CREATE_FLAVOR </B> <DD> how the window was created
|
||||
</DL>
|
||||
<DL><DT><B>MPI_WIN_MODEL </B> <DD> memory model for window
|
||||
</DL>
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Window flavors</H2>
|
||||
MPI_WIN_FLAVOR_CREATE - Window was created with MPI_WIN_CREATE.
|
||||
<DL><DT><B>MPI_WIN_FLAVOR_ALLOCATE </B> <DD> Window was created with MPI_WIN_ALLOCATE.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_WIN_FLAVOR_DYNAMIC </B> <DD> Window was created with MPI_WIN_CREATE_DYNAMIC.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_WIN_FLAVOR_SHARED </B> <DD> Window was created with MPI_WIN_ALLOCATE_SHARED.
|
||||
</DL>
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Window Memory Model</H2>
|
||||
MPI_WIN_SEPARATE - Separate public and private copies of window memory
|
||||
<DL><DT><B>MPI_WIN_UNIFIED </B> <DD> The publich and private copies are identical (by which
|
||||
we mean that updates are eventually observed without additional RMA operations)
|
||||
</DL>
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Window Lock Types</H2>
|
||||
MPI_LOCK_EXCLUSIVE - Only one process at a time will execute accesses
|
||||
within the lock
|
||||
<DL><DT><B>MPI_LOCK_SHARED </B> <DD> Not exclusive; multiple processes may execute accesses
|
||||
within the lock
|
||||
</DL>
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Window Assertions</H2>
|
||||
See section 11.5 in MPI 3.1 for a detailed description of each of these
|
||||
assertion values.
|
||||
MPI_MODE_NOCHECK - The matching calls to MPI_WIN_POST or MPI_WIN_START
|
||||
have already completed, or no process holds or will attempt to acquire, a
|
||||
conflicting lock.
|
||||
<DL><DT><B>MPI_MODE_NOSTORE </B> <DD> The local window has not been updated by stores
|
||||
since the last synchronization
|
||||
</DL>
|
||||
<DL><DT><B>MPI_MODE_NOPUT </B> <DD> The local window will not be updated by put or
|
||||
accumulate until the next synchronization
|
||||
</DL>
|
||||
<DL><DT><B>MPI_MODE_NOPRECEDE </B> <DD> The fence does not complete any locally issued RMA
|
||||
calls
|
||||
</DL>
|
||||
<DL><DT><B>MPI_MODE_NOSUCCEED </B> <DD> The fence does not start any locally issued RMA calls
|
||||
</DL>
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Predefined Info Object</H2>
|
||||
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
|
||||
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>)
|
||||
</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>
|
||||
</DL>
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Special value for error codes array</H2>
|
||||
MPI_ERRCODES_IGNORE - Ignore an array of error codes
|
||||
<P>
|
||||
<H2>MPI_T Constants</H2>
|
||||
MPI_T_VERBOSITY_USER_BASIC - Basic information of interest to users
|
||||
<DL><DT><B>MPI_T_VERBOSITY_USER_DETAIL </B> <DD> Detailed information of interest to users
|
||||
</DL>
|
||||
<DL><DT><B>MPI_T_VERBOSITY_USER_ALL </B> <DD> All remaining information of interest to users
|
||||
</DL>
|
||||
<DL><DT><B>MPI_T_VERBOSITY_TUNER_BASIC </B> <DD> Basic information required for tuning
|
||||
</DL>
|
||||
<DL><DT><B>MPI_T_VERBOSITY_TUNER_DETAIL </B> <DD> Detailed information required for tuning
|
||||
</DL>
|
||||
<DL><DT><B>MPI_T_VERBOSITY_TUNER_ALL </B> <DD> All remaining information required for tuning
|
||||
</DL>
|
||||
<DL><DT><B>MPI_T_VERBOSITY_MPIDEV_BASIC </B> <DD> Basic information for MPI implementors
|
||||
</DL>
|
||||
<P>
|
||||
<P>
|
||||
<DL><DT><B>MPI_T_VERBOSITY_MPIDEV_DETAIL </B> <DD> Detailed information for MPI implementors
|
||||
</DL>
|
||||
<DL><DT><B>MPI_T_VERBOSITY_MPIDEV_ALL </B> <DD> All remaining information for MPI implementors
|
||||
</DL>
|
||||
<DL><DT><B>MPI_T_BIND_NO_OBJECT </B> <DD> Applies globally to entire MPI process
|
||||
</DL>
|
||||
<DL><DT><B>MPI_T_BIND_MPI_COMM </B> <DD> MPI communicators
|
||||
</DL>
|
||||
<DL><DT><B>MPI_T_BIND_MPI_DATATYPE </B> <DD> MPI datatypes
|
||||
</DL>
|
||||
<DL><DT><B>MPI_T_BIND_MPI_ERRHANDLER </B> <DD> MPI error handlers
|
||||
</DL>
|
||||
<DL><DT><B>MPI_T_BIND_MPI_FILE </B> <DD> MPI file handles
|
||||
</DL>
|
||||
<DL><DT><B>MPI_T_BIND_MPI_GROUP </B> <DD> MPI groups
|
||||
</DL>
|
||||
<DL><DT><B>MPI_T_BIND_MPI_OP </B> <DD> MPI reduction operators
|
||||
</DL>
|
||||
<DL><DT><B>MPI_T_BIND_MPI_REQUEST </B> <DD> MPI requests
|
||||
</DL>
|
||||
<DL><DT><B>MPI_T_BIND_MPI_WIN </B> <DD> MPI windows for one-sided communication
|
||||
</DL>
|
||||
<DL><DT><B>MPI_T_BIND_MPI_MESSAGE </B> <DD> MPI message object
|
||||
</DL>
|
||||
<DL><DT><B>MPI_T_BIND_MPI_INFO </B> <DD> MPI info object
|
||||
</DL>
|
||||
<DL><DT><B>MPI_T_SCOPE_CONSTANT </B> <DD> read-only, value is constant
|
||||
</DL>
|
||||
<DL><DT><B>MPI_T_SCOPE_READONLY </B> <DD> read-only, cannot be written, but can
|
||||
change
|
||||
</DL>
|
||||
<DL><DT><B>MPI_T_SCOPE_LOCAL </B> <DD> may be writeable, writing is a local
|
||||
operation
|
||||
</DL>
|
||||
<DL><DT><B>MPI_T_SCOPE_GROUP </B> <DD> may be writeable, must be done to a
|
||||
group of processes, all processes in a group must be set to consistent values
|
||||
</DL>
|
||||
<DL><DT><B>MPI_T_SCOPE_GROUP_EQ </B> <DD> may be writeable, must be done to a
|
||||
group of processes, all processes in a group must be set to the same value
|
||||
</DL>
|
||||
<DL><DT><B>MPI_T_SCOPE_ALL </B> <DD> may be writeable, must be done to all
|
||||
processes, all connected processes must be set to consistent values
|
||||
</DL>
|
||||
<DL><DT><B>MPI_T_SCOPE_ALL_EQ </B> <DD> may be writeable, must be done to all
|
||||
processes, all connected processes must be set to the same value
|
||||
</DL>
|
||||
<DL><DT><B>MPI_T_PVAR_CLASS_STATE </B> <DD> set of discrete states (MPI_INT)
|
||||
</DL>
|
||||
<DL><DT><B>MPI_T_PVAR_CLASS_LEVEL </B> <DD> utilization level of a resource
|
||||
</DL>
|
||||
<DL><DT><B>MPI_T_PVAR_CLASS_SIZE </B> <DD> size of a resource
|
||||
</DL>
|
||||
<DL><DT><B>MPI_T_PVAR_CLASS_PERCENTAGE </B> <DD> percentage utilization of a resource
|
||||
</DL>
|
||||
<DL><DT><B>MPI_T_PVAR_CLASS_HIGHWATERMARK </B> <DD> high watermark of a resource
|
||||
</DL>
|
||||
<DL><DT><B>MPI_T_PVAR_CLASS_LOWWATERMARK </B> <DD> low watermark of a resource
|
||||
</DL>
|
||||
<DL><DT><B>MPI_T_PVAR_CLASS_COUNTER </B> <DD> number of occurances of an event
|
||||
</DL>
|
||||
<DL><DT><B>MPI_T_PVAR_CLASS_AGGREGATE </B> <DD> aggregate value over an event (e.g.,
|
||||
sum of all memory allocations)
|
||||
</DL>
|
||||
<DL><DT><B>MPI_T_PVAR_CLASS_TIMER </B> <DD> aggretate time spent executing event
|
||||
</DL>
|
||||
<DL><DT><B>MPI_T_PVAR_CLASS_GENERIC </B> <DD> used for any other time of performance
|
||||
variable
|
||||
</DL>
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Thread levels</H2>
|
||||
MPI_THREAD_SINGLE - Only one thread executes
|
||||
<DL><DT><B>MPI_THREAD_FUNNELED </B> <DD> Only the main thread makes MPI calls
|
||||
</DL>
|
||||
<DL><DT><B>MPI_THREAD_SERIALIZED </B> <DD> Only one thread at a time makes MPI calls
|
||||
</DL>
|
||||
<DL><DT><B>MPI_THREAD_MULTIPLE </B> <DD> Multiple threads may make MPI calls
|
||||
</DL>
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Special MPI types and functions</H2>
|
||||
<P>
|
||||
MPI_Aint - C type that holds any valid address.
|
||||
<DL><DT><B>MPI_Count </B> <DD> C type that holds any valid count.
|
||||
</DL>
|
||||
<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>) .
|
||||
</DL>
|
||||
<DL><DT><B>MPI_User_function </B> <DD> C function to combine values (see collective operations
|
||||
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>
|
||||
<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>
|
||||
<DL><DT><B>MPI_ERRORS_RETURN </B> <DD> Error handler that returns error codes (as value of
|
||||
MPI routine in C and through last argument in Fortran)
|
||||
</DL>
|
||||
</DL>
|
||||
<P>
|
||||
<H2>MPI Attribute Default Functions</H2>
|
||||
MPI_COMM_NULL_COPY_FN - Predefined attribute copy function for communicators
|
||||
<DL><DT><B>MPI_COMM_NULL_DELETE_FN </B> <DD> Predefined attribute delete function for communicators
|
||||
</DL>
|
||||
<DL><DT><B>MPI_COMM_DUP_FN </B> <DD> Predefined attribute duplicate function for communicators
|
||||
</DL>
|
||||
<DL><DT><B>MPI_WIN_NULL_COPY_FN </B> <DD> Predefined attribute copy function for windows
|
||||
</DL>
|
||||
<DL><DT><B>MPI_WIN_NULL_DELETE_FN </B> <DD> Predefined attribute delete function for windows
|
||||
</DL>
|
||||
<DL><DT><B>MPI_WIN_DUP_FN </B> <DD> Predefined attribute duplicate function for windows
|
||||
</DL>
|
||||
<DL><DT><B>MPI_TYPE_NULL_COPY_FN </B> <DD> Predefined attribute copy function for datatypes
|
||||
</DL>
|
||||
<DL><DT><B>MPI_TYPE_NULL_DELETE_FN </B> <DD> Predefined attribute delete function for datatypes
|
||||
</DL>
|
||||
<DL><DT><B>MPI_TYPE_DUP_FN </B> <DD> Predefined attribute duplicate function for datatypes
|
||||
</DL>
|
||||
</DL>
|
||||
<P>
|
||||
<H2>MPI-1 Attribute Default Functions</H2>
|
||||
MPI_NULL_COPY_FN - Predefined copy function
|
||||
<DL><DT><B>MPI_NULL_DELETE_FN </B> <DD> Predefined delete function
|
||||
</DL>
|
||||
<DL><DT><B>MPI_DUP_FN </B> <DD> Predefined duplication function
|
||||
</DL>
|
||||
</DL>
|
||||
<P>
|
||||
<H2>MPI Error classes</H2>
|
||||
MPI_SUCCESS - Successful return code
|
||||
<DL><DT><B>MPI_ERR_BUFFER </B> <DD> Invalid buffer pointer
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_COUNT </B> <DD> Invalid count argument
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_TYPE </B> <DD> Invalid datatype argument
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_TAG </B> <DD> Invalid tag argument
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_COMM </B> <DD> Invalid communicator
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_RANK </B> <DD> Invalid rank
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_ROOT </B> <DD> Invalid root
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_GROUP </B> <DD> Null group passed to function
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_OP </B> <DD> Invalid operation
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_TOPOLOGY </B> <DD> Invalid topology
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_DIMS </B> <DD> Illegal dimension argument
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_ARG </B> <DD> Invalid argument
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_UNKNOWN </B> <DD> Unknown error
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_TRUNCATE </B> <DD> Message truncated on receive
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_OTHER </B> <DD> Other error; use Error_string
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_INTERN </B> <DD> Internal error code
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_IN_STATUS </B> <DD> Look in status for error value
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_PENDING </B> <DD> Pending request
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_REQUEST </B> <DD> Invalid mpi_request handle
|
||||
</DL>
|
||||
<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>
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_BAD_FILE </B> <DD> Invalid file name (e.g., path name too long)
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_CONVERSION </B> <DD> An error occurred in a user supplied data
|
||||
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>
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_FILE_EXISTS </B> <DD> File exists
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_FILE_IN_USE </B> <DD> File operation could not be completed, as
|
||||
the file is currently open by some process
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_FILE </B> <DD> Invalid file handle
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_IO </B> <DD> Other I/O error
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_NO_SPACE </B> <DD> Not enough space
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_NO_SUCH_FILE </B> <DD> File does not exist
|
||||
</DL>
|
||||
<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>
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_INFO </B> <DD> Invalid info argument
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_INFO_KEY </B> <DD> Key longer than MPI_MAX_INFO_KEY
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_INFO_VALUE </B> <DD> Value longer than MPI_MAX_INFO_VAL
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_INFO_NOKEY </B> <DD> Invalid key passed to MPI_INFO_DELETE
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_NAME </B> <DD> Invalid service name passed to MPI_LOOKUP_NAME
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_NO_MEM </B> <DD> Alloc_mem could not allocate memory
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_NOT_SAME </B> <DD> Collective argument not identical on all
|
||||
processes, or collective routines called in a different order by different
|
||||
processes
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_PORT </B> <DD> Invalid port name passed to MPI_COMM_CONNECT
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_QUOTA </B> <DD> Quota exceeded
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_SERVICE </B> <DD> Invalid service name passed to MPI_UNPUBLISH_NAME
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_SPAWN </B> <DD> Error in spawning processes
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_UNSUPPORTED_OPERATION </B> <DD> Unsupported operation, such as seeking on
|
||||
a file which supports sequential access only
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_WIN </B> <DD> Invalid win argument
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_BASE </B> <DD> Invalid base passed to MPI_FREE_MEM
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_LOCKTYPE </B> <DD> Invalid locktype argument
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_KEYVAL </B> <DD> Erroneous attribute key
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_RMA_CONFLICT </B> <DD> Conflicting accesses to window
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_RMA_SYNC </B> <DD> Wrong synchronization of RMA calls
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_SIZE </B> <DD> Invalid size argument
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_DISP </B> <DD> Invalid disp argument
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_ASSERT </B> <DD> Invalid assert argument
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_RMA_RANGE </B> <DD> Target memory is not part of the window (in
|
||||
the case of a window created with MPI_WIN_CREATE_DYNAMIC, target memory is
|
||||
not attached)
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_RMA_ATTACH </B> <DD> Memory cannot be attached (e.g., because of
|
||||
resource exhaustion)
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_RMA_SHARED </B> <DD> Memory cannot be shared (e.g., some process in
|
||||
the group of the specified communicator cannot expose shared memory)
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_RMA_FLAVOR </B> <DD> Passed window has the wrong flavor for the
|
||||
called function
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_LASTCODE </B> <DD> Last error code -- always at end
|
||||
</DL>
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Error codes for MPI_T</H2>
|
||||
<P>
|
||||
MPI_T_ERR_MEMORY - Out of memory
|
||||
<DL><DT><B>MPI_T_ERR_NOT_INITIALIZED </B> <DD> Interface not initialized
|
||||
</DL>
|
||||
<DL><DT><B>MPI_T_ERR_CANNOT_INIT </B> <DD> Interface not in the state to be initialized
|
||||
</DL>
|
||||
<DL><DT><B>MPI_T_ERR_INVALID_INDEX </B> <DD> The index is invalid or has been deleted
|
||||
</DL>
|
||||
<DL><DT><B>MPI_T_ERR_INVALID_ITEM </B> <DD> Item index queried is out of range
|
||||
</DL>
|
||||
<DL><DT><B>MPI_T_ERR_INVALID_HANDLE </B> <DD> The handle is invalid
|
||||
</DL>
|
||||
<DL><DT><B>MPI_T_ERR_OUT_OF_HANDLES </B> <DD> No more handles available
|
||||
</DL>
|
||||
<DL><DT><B>MPI_T_ERR_OUT_OF_SESSIONS </B> <DD> No more sessions available
|
||||
</DL>
|
||||
<DL><DT><B>MPI_T_ERR_INVALID_SESSION </B> <DD> Session argument is not valid
|
||||
</DL>
|
||||
<DL><DT><B>MPI_T_ERR_CVAR_SET_NOT_NOW </B> <DD> Cvar can't be set at this moment
|
||||
</DL>
|
||||
<DL><DT><B>MPI_T_ERR_CVAR_SET_NEVER </B> <DD> Cvar can't be set until end of execution
|
||||
</DL>
|
||||
<DL><DT><B>MPI_T_ERR_PVAR_NO_STARTSTOP </B> <DD> Pvar can't be started or stopped
|
||||
</DL>
|
||||
<DL><DT><B>MPI_T_ERR_PVAR_NO_WRITE </B> <DD> Pvar can't be written or reset
|
||||
</DL>
|
||||
<DL><DT><B>MPI_T_ERR_PVAR_NO_ATOMIC </B> <DD> Pvar can't be R/W atomically
|
||||
</DL>
|
||||
<DL><DT><B>MPI_T_ERR_INVALID_NAME </B> <DD> Name doesn't match
|
||||
</DL>
|
||||
<DL><DT><B>MPI_T_ERR_INVALID </B> <DD> Invalid use of the interface or bad parameter
|
||||
values(s)
|
||||
</DL>
|
||||
</DL>
|
||||
<P>
|
||||
</BODY></HTML>
|
||||
18
macx64/mpi/mpich/share/doc/mpich/www3/MPIR_Type_commit.html
Normal file
18
macx64/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
macx64/mpi/mpich/share/doc/mpich/www3/MPIR_Type_dup.html
Normal file
29
macx64/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
macx64/mpi/mpich/share/doc/mpich/www3/MPIR_Type_indexed.html
Normal file
39
macx64/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
macx64/mpi/mpich/share/doc/mpich/www3/MPIR_Type_struct.html
Normal file
38
macx64/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
macx64/mpi/mpich/share/doc/mpich/www3/MPIR_Type_vector.html
Normal file
38
macx64/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>
|
||||
61
macx64/mpi/mpich/share/doc/mpich/www3/MPIX_Comm_agree.html
Normal file
61
macx64/mpi/mpich/share/doc/mpich/www3/MPIX_Comm_agree.html
Normal file
@@ -0,0 +1,61 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPIX_Comm_agree</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPIX_Comm_agree"><H1>MPIX_Comm_agree</H1></A>
|
||||
Performs agreement operation on comm
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
int MPIX_Comm_agree(MPI_Comm comm, int *flag)
|
||||
</PRE>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL><DT><B>comm </B> <DD> communicator (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL><DT><B>newcomm </B> <DD> new communicator (handle)
|
||||
</DL>
|
||||
<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.
|
||||
<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
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<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.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
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
|
||||
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
|
||||
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>).
|
||||
</DL>
|
||||
<P>
|
||||
</BODY></HTML>
|
||||
@@ -0,0 +1,61 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPIX_Comm_failure_ack</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPIX_Comm_failure_ack"><H1>MPIX_Comm_failure_ack</H1></A>
|
||||
Acknowledge the current group of failed processes
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
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.
|
||||
<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.
|
||||
<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
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<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.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
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
|
||||
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
|
||||
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>).
|
||||
</DL>
|
||||
</BODY></HTML>
|
||||
@@ -0,0 +1,65 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPIX_Comm_failure_get_acked</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPIX_Comm_failure_get_acked"><H1>MPIX_Comm_failure_get_acked</H1></A>
|
||||
Get the group of acknowledged failures.
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
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)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL><DT><B>failed_group </B> <DD> Group (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.
|
||||
<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.
|
||||
<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
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<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.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
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
|
||||
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
|
||||
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>).
|
||||
</DL>
|
||||
</BODY></HTML>
|
||||
50
macx64/mpi/mpich/share/doc/mpich/www3/MPIX_Comm_revoke.html
Normal file
50
macx64/mpi/mpich/share/doc/mpich/www3/MPIX_Comm_revoke.html
Normal file
@@ -0,0 +1,50 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPIX_Comm_revoke</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPIX_Comm_revoke"><H1>MPIX_Comm_revoke</H1></A>
|
||||
Prevent a communicator from being used in the future
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
int MPIX_Comm_revoke(MPI_Comm comm)
|
||||
</PRE>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL><DT><B>comm </B> <DD> communicator to revoke
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Notes</H2>
|
||||
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
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<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.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
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
|
||||
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
|
||||
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>
|
||||
</BODY></HTML>
|
||||
61
macx64/mpi/mpich/share/doc/mpich/www3/MPIX_Comm_shrink.html
Normal file
61
macx64/mpi/mpich/share/doc/mpich/www3/MPIX_Comm_shrink.html
Normal file
@@ -0,0 +1,61 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPIX_Comm_shrink</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPIX_Comm_shrink"><H1>MPIX_Comm_shrink</H1></A>
|
||||
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)
|
||||
</PRE>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL><DT><B>comm </B> <DD> communicator (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL><DT><B>newcomm </B> <DD> new communicator (handle)
|
||||
</DL>
|
||||
<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.
|
||||
<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
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<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.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
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
|
||||
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
|
||||
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>).
|
||||
</DL>
|
||||
<P>
|
||||
</BODY></HTML>
|
||||
68
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Abort.html
Normal file
68
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Abort.html
Normal file
@@ -0,0 +1,68 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPI_Abort</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPI_Abort"><H1>MPI_Abort</H1></A>
|
||||
Terminates MPI execution environment
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
int MPI_Abort(MPI_Comm comm, int errorcode)
|
||||
</PRE>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>comm </B><DD>communicator of tasks to abort
|
||||
|
||||
<DT><B>errorcode </B><DD>error code to return to invoking environment
|
||||
</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.
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
<P>
|
||||
The user is responsible for ensuring that multiple threads do not try to
|
||||
update the same MPI object from different threads. This routine should
|
||||
not be used from within a signal handler.
|
||||
<P>
|
||||
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
|
||||
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
|
||||
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
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<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.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
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
|
||||
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
|
||||
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>
|
||||
</BODY></HTML>
|
||||
90
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Accumulate.html
Normal file
90
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Accumulate.html
Normal file
@@ -0,0 +1,90 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPI_Accumulate</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPI_Accumulate"><H1>MPI_Accumulate</H1></A>
|
||||
Accumulate data into the target process using remote memory access
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
int MPI_Accumulate(const void *origin_addr, int origin_count, MPI_Datatype
|
||||
origin_datatype, int target_rank, MPI_Aint
|
||||
target_disp, int target_count, MPI_Datatype
|
||||
target_datatype, MPI_Op op, MPI_Win win)
|
||||
</PRE>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>origin_addr </B><DD>initial address of buffer (choice)
|
||||
|
||||
<DT><B>origin_count </B><DD>number of entries in buffer (nonnegative integer)
|
||||
|
||||
<DT><B>origin_datatype </B><DD>datatype of each buffer entry (handle)
|
||||
|
||||
<DT><B>target_rank </B><DD>rank of target (nonnegative integer)
|
||||
|
||||
<DT><B>target_disp </B><DD>displacement from start of window to beginning of target
|
||||
buffer (nonnegative integer)
|
||||
|
||||
<DT><B>target_count </B><DD>number of entries in target buffer (nonnegative integer)
|
||||
|
||||
<DT><B>target_datatype </B><DD>datatype of each entry in target buffer (handle)
|
||||
|
||||
<DT><B>op </B><DD>predefined reduce operation (handle)
|
||||
|
||||
<DT><B>win </B><DD>window object (handle)
|
||||
</DL>
|
||||
<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>).
|
||||
<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
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<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.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
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
|
||||
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
|
||||
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>).
|
||||
</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>.
|
||||
</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
|
||||
in a communication call.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_WIN </B> <DD> Invalid MPI window object
|
||||
</DL>
|
||||
<P>
|
||||
<H2>See Also</H2>
|
||||
MPI_Raccumulate
|
||||
<BR>
|
||||
</BODY></HTML>
|
||||
@@ -0,0 +1,56 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPI_Add_error_class</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPI_Add_error_class"><H1>MPI_Add_error_class</H1></A>
|
||||
Add an MPI error class to the known classes
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
int MPI_Add_error_class(int *errorclass)
|
||||
</PRE>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL><DT><B>errorclass </B> <DD> New error class
|
||||
</DL>
|
||||
<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.
|
||||
<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
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<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.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
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
|
||||
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
|
||||
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
|
||||
about this error code.
|
||||
</DL>
|
||||
</BODY></HTML>
|
||||
@@ -0,0 +1,60 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPI_Add_error_code</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPI_Add_error_code"><H1>MPI_Add_error_code</H1></A>
|
||||
Add an MPI error code to an MPI error class
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
int MPI_Add_error_code(int errorclass, int *errorcode)
|
||||
</PRE>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL><DT><B>errorclass </B> <DD> Error class to add an error code.
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL><DT><B>errorcode </B> <DD> New error code for this error class.
|
||||
</DL>
|
||||
<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.
|
||||
<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
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<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.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
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
|
||||
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
|
||||
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
|
||||
about this error code.
|
||||
</DL>
|
||||
</BODY></HTML>
|
||||
@@ -0,0 +1,68 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPI_Add_error_string</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPI_Add_error_string"><H1>MPI_Add_error_string</H1></A>
|
||||
Associates an error string with an MPI error code or class
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
int MPI_Add_error_string(int errorcode, const char *string)
|
||||
</PRE>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>errorcode </B><DD>error code or class (integer)
|
||||
|
||||
<DT><B>string </B><DD>text corresponding to errorcode (string)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Notes</H2>
|
||||
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
|
||||
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
|
||||
with this routine.
|
||||
<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.
|
||||
<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
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<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.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
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
|
||||
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
|
||||
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>
|
||||
</BODY></HTML>
|
||||
72
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Address.html
Normal file
72
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Address.html
Normal file
@@ -0,0 +1,72 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPI_Address</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPI_Address"><H1>MPI_Address</H1></A>
|
||||
Gets the address of a location in memory
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
int MPI_Address(void *location, MPI_Aint * address)
|
||||
</PRE>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL><DT><B>location </B> <DD> location in caller memory (choice)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL><DT><B>address </B> <DD> address of location (address integer)
|
||||
</DL>
|
||||
<P>
|
||||
<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
|
||||
may not be true of systems with word- rather than byte-oriented
|
||||
instructions or systems with segmented address spaces.
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
<P>
|
||||
This routine is both thread- and interrupt-safe.
|
||||
This means that this routine may safely be used by multiple threads and
|
||||
from within a signal handler.
|
||||
<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_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
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<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.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
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
|
||||
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
|
||||
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
|
||||
about this error code.
|
||||
</DL>
|
||||
</BODY></HTML>
|
||||
40
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Aint_add.html
Normal file
40
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Aint_add.html
Normal file
@@ -0,0 +1,40 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPI_Aint_add</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPI_Aint_add"><H1>MPI_Aint_add</H1></A>
|
||||
Returns the sum of base and disp
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
MPI_Aint MPI_Aint_add(MPI_Aint base, MPI_Aint disp)
|
||||
</PRE>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>base </B><DD>base address (integer)
|
||||
|
||||
<DT><B>disp </B><DD>displacement (integer)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Return value</H2>
|
||||
Sum of the base and disp argument
|
||||
<P>
|
||||
<H2>Notes</H2>
|
||||
MPI_Aint_Add produces a new MPI_Aint value that is equivalent to the sum of the
|
||||
base and disp arguments, where base represents a base address returned by a call
|
||||
to MPI_GET_ADDRESS and disp represents a signed integer displacement. The resulting
|
||||
address is valid only at the process that generated base, and it must correspond
|
||||
to a location in the same object referenced by base. The addition is performed in
|
||||
a manner that results in the correct MPI_Aint representation of the output address,
|
||||
as if the process that originally produced base had called:
|
||||
<PRE>
|
||||
MPI_Get_address((char *) base + disp, &result)
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
<H2>See Also</H2>
|
||||
MPI_Aint_diff
|
||||
<BR>
|
||||
</BODY></HTML>
|
||||
41
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Aint_diff.html
Normal file
41
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Aint_diff.html
Normal file
@@ -0,0 +1,41 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPI_Aint_diff</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPI_Aint_diff"><H1>MPI_Aint_diff</H1></A>
|
||||
Returns the difference between addr1 and addr2
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
MPI_Aint MPI_Aint_diff(MPI_Aint addr1, MPI_Aint addr2)
|
||||
</PRE>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>addr1 </B><DD>minuend address (integer)
|
||||
|
||||
<DT><B>addr2 </B><DD>subtrahend address (integer)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Return value</H2>
|
||||
Difference between addr1 and addr2
|
||||
<P>
|
||||
<H2>Notes</H2>
|
||||
MPI_Aint_diff produces a new MPI_Aint value that is equivalent to the difference
|
||||
between addr1 and addr2 arguments, where addr1 and addr2 represent addresses
|
||||
returned by calls to MPI_GET_ADDRESS. The resulting address is valid only at the
|
||||
process that generated addr1 and addr2, and addr1 and addr2 must correspond to
|
||||
locations in the same object in the same process. The difference is calculated
|
||||
in a manner that results the signed difference from addr1 to addr2, as if the
|
||||
process that originally produced the addresses had called
|
||||
<PRE>
|
||||
(char *) addr1 - (char *) addr2
|
||||
</PRE>
|
||||
|
||||
on the addresses initially passed to MPI_GET_ADDRESS.
|
||||
<P>
|
||||
<H2>See Also</H2>
|
||||
MPI_Aint_add
|
||||
<BR>
|
||||
</BODY></HTML>
|
||||
106
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Allgather.html
Normal file
106
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Allgather.html
Normal file
@@ -0,0 +1,106 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPI_Allgather</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPI_Allgather"><H1>MPI_Allgather</H1></A>
|
||||
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)
|
||||
</PRE>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>sendbuf </B><DD>starting address of send buffer (choice)
|
||||
|
||||
<DT><B>sendcount </B><DD>number of elements in send buffer (integer)
|
||||
|
||||
<DT><B>sendtype </B><DD>data type of send buffer elements (handle)
|
||||
|
||||
<DT><B>recvcount </B><DD>number of elements received from any process (integer)
|
||||
|
||||
<DT><B>recvtype </B><DD>data type of receive buffer elements (handle)
|
||||
|
||||
<DT><B>comm </B><DD>communicator (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL><DT><B>recvbuf </B> <DD> address of receive buffer (choice)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Notes</H2>
|
||||
The MPI standard (1.0 and 1.1) says that
|
||||
<BR>
|
||||
<P>
|
||||
<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>
|
||||
<P>
|
||||
<BR>
|
||||
<P>
|
||||
This is misleading; a better description is
|
||||
<BR>
|
||||
<P>
|
||||
<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>
|
||||
<P>
|
||||
<BR>
|
||||
<P>
|
||||
This text was suggested by Rajeev Thakur and has been adopted as a
|
||||
clarification by the MPI Forum.
|
||||
<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.
|
||||
<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
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<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.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
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
|
||||
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
|
||||
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>).
|
||||
</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
|
||||
in a communication call.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_BUFFER </B> <DD> Invalid buffer pointer. Usually a null buffer where
|
||||
one is not valid.
|
||||
</DL>
|
||||
</BODY></HTML>
|
||||
110
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Allgatherv.html
Normal file
110
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Allgatherv.html
Normal file
@@ -0,0 +1,110 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPI_Allgatherv</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPI_Allgatherv"><H1>MPI_Allgatherv</H1></A>
|
||||
Gathers data from all tasks and deliver the combined data to all tasks
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
int MPI_Allgatherv(const void *sendbuf, int sendcount, MPI_Datatype sendtype,
|
||||
void *recvbuf, const int *recvcounts, const int *displs,
|
||||
MPI_Datatype recvtype, MPI_Comm comm)
|
||||
</PRE>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>sendbuf </B><DD>starting address of send buffer (choice)
|
||||
|
||||
<DT><B>sendcount </B><DD>number of elements in send buffer (integer)
|
||||
|
||||
<DT><B>sendtype </B><DD>data type of send buffer elements (handle)
|
||||
|
||||
<DT><B>recvcounts </B><DD>integer array (of length group size)
|
||||
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>
|
||||
<DT><B>recvtype </B><DD>data type of receive buffer elements (handle)
|
||||
|
||||
<DT><B>comm </B><DD>communicator (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL><DT><B>recvbuf </B> <DD> address of receive buffer (choice)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Notes</H2>
|
||||
The MPI standard (1.0 and 1.1) says that
|
||||
<BR>
|
||||
<P>
|
||||
<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>
|
||||
<P>
|
||||
<BR>
|
||||
<P>
|
||||
This is misleading; a better description is
|
||||
<BR>
|
||||
<P>
|
||||
<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>
|
||||
<P>
|
||||
<BR>
|
||||
<P>
|
||||
This text was suggested by Rajeev Thakur, and has been adopted as a
|
||||
clarification to the MPI standard by the MPI-Forum.
|
||||
<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.
|
||||
<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
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<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.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
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
|
||||
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
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL><DT><B>MPI_ERR_BUFFER </B> <DD> Invalid buffer pointer. Usually a null buffer where
|
||||
one is not valid.
|
||||
</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
|
||||
in a communication call.
|
||||
</DL>
|
||||
</BODY></HTML>
|
||||
79
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Alloc_mem.html
Normal file
79
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Alloc_mem.html
Normal file
@@ -0,0 +1,79 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPI_Alloc_mem</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPI_Alloc_mem"><H1>MPI_Alloc_mem</H1></A>
|
||||
Allocate memory for message passing and RMA
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
int MPI_Alloc_mem(MPI_Aint size, MPI_Info info, void *baseptr)
|
||||
</PRE>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>size </B><DD>size of memory segment in bytes (nonnegative integer)
|
||||
|
||||
<DT><B>info </B><DD>info argument (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL><DT><B>baseptr </B> <DD> pointer to beginning of memory segment allocated
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Notes</H2>
|
||||
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
|
||||
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
|
||||
pointer to a pointer.
|
||||
<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.
|
||||
<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
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<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.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
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
|
||||
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
|
||||
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_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>).
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_NO_MEM </B> <DD> Insufficient memory available for allocation by
|
||||
<TT>MPI_Alloc_mem
|
||||
</TT>
|
||||
</DL>
|
||||
</BODY></HTML>
|
||||
93
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Allreduce.html
Normal file
93
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Allreduce.html
Normal file
@@ -0,0 +1,93 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPI_Allreduce</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPI_Allreduce"><H1>MPI_Allreduce</H1></A>
|
||||
Combines values from all processes and distributes the result back to all processes
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
int MPI_Allreduce(const void *sendbuf, void *recvbuf, int count,
|
||||
MPI_Datatype datatype, MPI_Op op, MPI_Comm comm)
|
||||
</PRE>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>sendbuf </B><DD>starting address of send buffer (choice)
|
||||
|
||||
<DT><B>count </B><DD>number of elements in send buffer (integer)
|
||||
|
||||
<DT><B>datatype </B><DD>data type of elements of send buffer (handle)
|
||||
|
||||
<DT><B>op </B><DD>operation (handle)
|
||||
|
||||
<DT><B>comm </B><DD>communicator (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL><DT><B>recvbuf </B> <DD> starting address of receive buffer (choice)
|
||||
</DL>
|
||||
<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.
|
||||
<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
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<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.
|
||||
<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>,
|
||||
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>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
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
|
||||
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
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL><DT><B>MPI_ERR_BUFFER </B> <DD> Invalid buffer pointer. Usually a null buffer where
|
||||
one is not valid.
|
||||
</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
|
||||
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>
|
||||
<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>).
|
||||
</DL>
|
||||
</BODY></HTML>
|
||||
80
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Alltoall.html
Normal file
80
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Alltoall.html
Normal file
@@ -0,0 +1,80 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPI_Alltoall</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPI_Alltoall"><H1>MPI_Alltoall</H1></A>
|
||||
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)
|
||||
</PRE>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>sendbuf </B><DD>starting address of send buffer (choice)
|
||||
|
||||
<DT><B>sendcount </B><DD>number of elements to send to each process (integer)
|
||||
|
||||
<DT><B>sendtype </B><DD>data type of send buffer elements (handle)
|
||||
|
||||
<DT><B>recvcount </B><DD>number of elements received from any process (integer)
|
||||
|
||||
<DT><B>recvtype </B><DD>data type of receive buffer elements (handle)
|
||||
|
||||
<DT><B>comm </B><DD>communicator (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL><DT><B>recvbuf </B> <DD> address of receive buffer (choice)
|
||||
</DL>
|
||||
<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.
|
||||
<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
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<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.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
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
|
||||
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
|
||||
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>).
|
||||
</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
|
||||
in a communication call.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_BUFFER </B> <DD> Invalid buffer pointer. Usually a null buffer where
|
||||
one is not valid.
|
||||
</DL>
|
||||
</BODY></HTML>
|
||||
92
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Alltoallv.html
Normal file
92
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Alltoallv.html
Normal file
@@ -0,0 +1,92 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPI_Alltoallv</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPI_Alltoallv"><H1>MPI_Alltoallv</H1></A>
|
||||
Sends data from all to all processes; each process may send a different amount of data and provide displacements for the input and output data.
|
||||
<H2>Synopsis</H2>
|
||||
<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)
|
||||
</PRE>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>sendbuf </B><DD>starting address of send buffer (choice)
|
||||
|
||||
<DT><B>sendcounts </B><DD>integer array equal to the group size
|
||||
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>
|
||||
<DT><B>sendtype </B><DD>data type of send buffer elements (handle)
|
||||
|
||||
<DT><B>recvcounts </B><DD>integer array equal to the group size
|
||||
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>
|
||||
<DT><B>recvtype </B><DD>data type of receive buffer elements (handle)
|
||||
|
||||
<DT><B>comm </B><DD>communicator (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL><DT><B>recvbuf </B> <DD> address of receive buffer (choice)
|
||||
</DL>
|
||||
<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.
|
||||
<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
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<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.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
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
|
||||
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
|
||||
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>).
|
||||
</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
|
||||
in a communication call.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_BUFFER </B> <DD> Invalid buffer pointer. Usually a null buffer where
|
||||
one is not valid.
|
||||
</DL>
|
||||
</BODY></HTML>
|
||||
96
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Alltoallw.html
Normal file
96
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Alltoallw.html
Normal file
@@ -0,0 +1,96 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPI_Alltoallw</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPI_Alltoallw"><H1>MPI_Alltoallw</H1></A>
|
||||
Generalized all-to-all communication allowing different datatypes, counts, and displacements for each partner
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
int MPI_Alltoallw(const void *sendbuf, const int sendcounts[],
|
||||
const int sdispls[], const MPI_Datatype sendtypes[],
|
||||
void *recvbuf, const int recvcounts[], const int rdispls[],
|
||||
const MPI_Datatype recvtypes[], MPI_Comm comm)
|
||||
</PRE>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>sendbuf </B><DD>starting address of send buffer (choice)
|
||||
|
||||
<DT><B>sendcounts </B><DD>integer array equal to the group size specifying the number of
|
||||
elements to send to each processor (integer)
|
||||
|
||||
<DT><B>sdispls </B><DD>integer array (of length group size). Entry j specifies the
|
||||
displacement in bytes (relative to sendbuf) from which to take the outgoing
|
||||
data destined for process j
|
||||
|
||||
<DT><B>sendtypes </B><DD>array of datatypes (of length group size). Entry j specifies the
|
||||
type of data to send to process j (handle)
|
||||
|
||||
<DT><B>recvcounts </B><DD>integer array equal to the group size specifying the number of
|
||||
elements that can be received from each processor (integer)
|
||||
|
||||
<DT><B>rdispls </B><DD>integer array (of length group size). Entry i specifies the
|
||||
displacement in bytes (relative to recvbuf) at which to place the incoming
|
||||
data from process i
|
||||
|
||||
<DT><B>recvtypes </B><DD>array of datatypes (of length group size). Entry i specifies
|
||||
the type of data received from process i (handle)
|
||||
|
||||
<DT><B>comm </B><DD>communicator (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL><DT><B>recvbuf </B> <DD> address of receive buffer (choice)
|
||||
</DL>
|
||||
<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.
|
||||
<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
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<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.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
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
|
||||
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
|
||||
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>).
|
||||
</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>).
|
||||
</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
|
||||
in a communication call.
|
||||
</DL>
|
||||
</BODY></HTML>
|
||||
69
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Attr_delete.html
Normal file
69
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Attr_delete.html
Normal file
@@ -0,0 +1,69 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPI_Attr_delete</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPI_Attr_delete"><H1>MPI_Attr_delete</H1></A>
|
||||
Deletes an attribute value associated with a key on a communicator
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
int MPI_Attr_delete(MPI_Comm comm, int keyval)
|
||||
</PRE>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>comm </B><DD>communicator to which attribute is attached (handle)
|
||||
|
||||
<DT><B>keyval </B><DD>The key value of the deleted attribute (integer)
|
||||
</DL>
|
||||
<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.
|
||||
<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>.
|
||||
<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
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<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.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
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
|
||||
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
|
||||
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>).
|
||||
</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>
|
||||
</BODY></HTML>
|
||||
94
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Attr_get.html
Normal file
94
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Attr_get.html
Normal file
@@ -0,0 +1,94 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPI_Attr_get</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPI_Attr_get"><H1>MPI_Attr_get</H1></A>
|
||||
Retrieves attribute value by key
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
int MPI_Attr_get(MPI_Comm comm, int keyval, void *attribute_val, int *flag)
|
||||
</PRE>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>comm </B><DD>communicator to which attribute is attached (handle)
|
||||
|
||||
<DT><B>keyval </B><DD>key value (integer)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL>
|
||||
<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
|
||||
</DL>
|
||||
<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.
|
||||
<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
|
||||
pointer to be passed without additional casts.
|
||||
<P>
|
||||
<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.
|
||||
<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>.
|
||||
<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
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<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.
|
||||
<P>
|
||||
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;
|
||||
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
|
||||
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
|
||||
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>).
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_KEYVAL </B> <DD> Invalid keyval
|
||||
</DL>
|
||||
<P>
|
||||
<H2>See Also</H2>
|
||||
MPI_Attr_put, MPI_Keyval_create, MPI_Attr_delete, MPI_Comm_get_attr
|
||||
<BR>
|
||||
</BODY></HTML>
|
||||
93
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Attr_put.html
Normal file
93
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Attr_put.html
Normal file
@@ -0,0 +1,93 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPI_Attr_put</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPI_Attr_put"><H1>MPI_Attr_put</H1></A>
|
||||
Stores attribute value associated with a key
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
int MPI_Attr_put(MPI_Comm comm, int keyval, void *attribute_val)
|
||||
</PRE>
|
||||
<H2>Input Parameters</H2>
|
||||
<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>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.
|
||||
<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,
|
||||
it is a single
|
||||
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>).
|
||||
<P>
|
||||
If an attribute is already present, the delete function (specified when the
|
||||
corresponding keyval was created) will be called.
|
||||
<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.
|
||||
<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>.
|
||||
<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
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<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.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
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
|
||||
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
|
||||
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>).
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_KEYVAL </B> <DD> Invalid keyval
|
||||
</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>
|
||||
<H2>See Also</H2>
|
||||
MPI_Attr_get, MPI_Keyval_create, MPI_Attr_delete, MPI_Comm_set_attr
|
||||
<BR>
|
||||
</BODY></HTML>
|
||||
61
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Barrier.html
Normal file
61
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Barrier.html
Normal file
@@ -0,0 +1,61 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPI_Barrier</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPI_Barrier"><H1>MPI_Barrier</H1></A>
|
||||
Blocks until all processes in the communicator have reached this routine.
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
int MPI_Barrier(MPI_Comm comm)
|
||||
</PRE>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL><DT><B>comm </B> <DD> communicator (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Notes</H2>
|
||||
Blocks the caller until all processes in the communicator have called it;
|
||||
that is, the call returns at any process only after all members of the
|
||||
communicator have entered the call.
|
||||
<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.
|
||||
<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
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<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.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
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
|
||||
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
|
||||
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>).
|
||||
</DL>
|
||||
</BODY></HTML>
|
||||
81
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Bcast.html
Normal file
81
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Bcast.html
Normal file
@@ -0,0 +1,81 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPI_Bcast</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPI_Bcast"><H1>MPI_Bcast</H1></A>
|
||||
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)
|
||||
</PRE>
|
||||
<H2>Input/Output Parameters</H2>
|
||||
<DL><DT><B>buffer </B> <DD> starting address of buffer (choice)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>count </B><DD>number of entries in buffer (integer)
|
||||
|
||||
<DT><B>datatype </B><DD>data type of buffer (handle)
|
||||
|
||||
<DT><B>root </B><DD>rank of broadcast root (integer)
|
||||
|
||||
<DT><B>comm </B><DD>communicator (handle)
|
||||
</DL>
|
||||
<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.
|
||||
<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
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<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.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
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
|
||||
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
|
||||
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>).
|
||||
</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
|
||||
in a communication call.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_BUFFER </B> <DD> Invalid buffer pointer. Usually a null buffer where
|
||||
one is not valid.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_ROOT </B> <DD> Invalid root. The root must be specified as a rank in the
|
||||
communicator. Ranks must be between zero and the size of the communicator
|
||||
minus one.
|
||||
</DL>
|
||||
</BODY></HTML>
|
||||
118
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Bsend.html
Normal file
118
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Bsend.html
Normal file
@@ -0,0 +1,118 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPI_Bsend</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPI_Bsend"><H1>MPI_Bsend</H1></A>
|
||||
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)
|
||||
</PRE>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>buf </B><DD>initial address of send buffer (choice)
|
||||
|
||||
<DT><B>count </B><DD>number of elements in send buffer (nonnegative integer)
|
||||
|
||||
<DT><B>datatype </B><DD>datatype of each send buffer element (handle)
|
||||
|
||||
<DT><B>dest </B><DD>rank of destination (integer)
|
||||
|
||||
<DT><B>tag </B><DD>message tag (integer)
|
||||
|
||||
<DT><B>comm </B><DD>communicator (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<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>).
|
||||
<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
|
||||
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);
|
||||
for (i=0; i<m; i++) {
|
||||
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
|
||||
buffer.
|
||||
<P>
|
||||
In C, you can
|
||||
force the messages to be delivered by
|
||||
<PRE>
|
||||
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
|
||||
delivered.)
|
||||
<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.
|
||||
<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
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<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.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
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
|
||||
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
|
||||
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>).
|
||||
</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
|
||||
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>.
|
||||
</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>.
|
||||
</DL>
|
||||
<P>
|
||||
<H2>See Also</H2>
|
||||
MPI_Buffer_attach, MPI_Ibsend, MPI_Bsend_init
|
||||
<BR>
|
||||
</BODY></HTML>
|
||||
92
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Bsend_init.html
Normal file
92
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Bsend_init.html
Normal file
@@ -0,0 +1,92 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPI_Bsend_init</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPI_Bsend_init"><H1>MPI_Bsend_init</H1></A>
|
||||
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)
|
||||
</PRE>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>buf </B><DD>initial address of send buffer (choice)
|
||||
|
||||
<DT><B>count </B><DD>number of elements sent (integer)
|
||||
|
||||
<DT><B>datatype </B><DD>type of each element (handle)
|
||||
|
||||
<DT><B>dest </B><DD>rank of destination (integer)
|
||||
|
||||
<DT><B>tag </B><DD>message tag (integer)
|
||||
|
||||
<DT><B>comm </B><DD>communicator (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL><DT><B>request </B> <DD> communication request (handle)
|
||||
</DL>
|
||||
<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.
|
||||
<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
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<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.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
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
|
||||
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
|
||||
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>).
|
||||
</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
|
||||
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>.
|
||||
</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>.
|
||||
</DL>
|
||||
<P>
|
||||
<H2>See Also</H2>
|
||||
MPI_Buffer_attach
|
||||
<BR>
|
||||
</BODY></HTML>
|
||||
98
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Buffer_attach.html
Normal file
98
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Buffer_attach.html
Normal file
@@ -0,0 +1,98 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPI_Buffer_attach</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPI_Buffer_attach"><H1>MPI_Buffer_attach</H1></A>
|
||||
Attaches a user-provided buffer for sending
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
int MPI_Buffer_attach(void *buffer, int size)
|
||||
</PRE>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>buffer </B><DD>initial buffer address (choice)
|
||||
|
||||
<DT><B>size </B><DD>buffer size, in bytes (integer)
|
||||
</DL>
|
||||
<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>.
|
||||
In other words, in the code
|
||||
<PRE>
|
||||
MPI_Buffer_attach(buffer, size);
|
||||
MPI_Bsend(..., count=20, datatype=type1, ...);
|
||||
...
|
||||
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 computed by
|
||||
<PRE>
|
||||
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 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).
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
<P>
|
||||
The user is responsible for ensuring that multiple threads do not try to
|
||||
update the same MPI object from different threads. This routine should
|
||||
not be used from within a signal handler.
|
||||
<P>
|
||||
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
|
||||
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
|
||||
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>.
|
||||
<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
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<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.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
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
|
||||
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
|
||||
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_BUFFER </B> <DD> Invalid buffer pointer. Usually a null buffer where
|
||||
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>.
|
||||
</DL>
|
||||
<P>
|
||||
<H2>See Also</H2>
|
||||
MPI_Buffer_detach, MPI_Bsend
|
||||
<BR>
|
||||
</BODY></HTML>
|
||||
96
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Buffer_detach.html
Normal file
96
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Buffer_detach.html
Normal file
@@ -0,0 +1,96 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPI_Buffer_detach</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPI_Buffer_detach"><H1>MPI_Buffer_detach</H1></A>
|
||||
Removes an existing buffer (for use in MPI_Bsend etc)
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
int MPI_Buffer_detach(void *buffer_addr, int *size)
|
||||
</PRE>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>buffer_addr </B><DD>initial buffer address (choice)
|
||||
|
||||
<DT><B>size </B><DD>buffer size, in bytes (integer)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Notes</H2>
|
||||
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);
|
||||
...
|
||||
... library code ...
|
||||
...
|
||||
MPI_Buffer_detach(&dummy, &idummy);
|
||||
MPI_Buffer_attach(ptr, size);
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
This is much like the action of the Unix signal routine and has the same
|
||||
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
|
||||
<P>
|
||||
<PRE>
|
||||
The statements made in this section describe the behavior of MPI for
|
||||
buffered-mode sends. When no buffer is currently associated, MPI behaves
|
||||
as if a zero-sized buffer is associated with the process.
|
||||
</PRE>
|
||||
|
||||
<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.
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
<P>
|
||||
The user is responsible for ensuring that multiple threads do not try to
|
||||
update the same MPI object from different threads. This routine should
|
||||
not be used from within a signal handler.
|
||||
<P>
|
||||
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
|
||||
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
|
||||
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>.
|
||||
<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
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<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.
|
||||
<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
|
||||
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
|
||||
really the address of a void pointer. See the rationale in the
|
||||
standard for more details.
|
||||
<P>
|
||||
<H2>See Also</H2>
|
||||
MPI_Buffer_attach
|
||||
<BR>
|
||||
</BODY></HTML>
|
||||
86
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Cancel.html
Normal file
86
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Cancel.html
Normal file
@@ -0,0 +1,86 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPI_Cancel</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPI_Cancel"><H1>MPI_Cancel</H1></A>
|
||||
Cancels a communication request
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
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 user to cancel these unsatisfied requests.
|
||||
<P>
|
||||
Cancelling a send operation is much more difficult, in large part because the
|
||||
send will usually be at least partially complete (the information on the tag,
|
||||
size, and source are usually sent immediately to the destination).
|
||||
Users are
|
||||
advised that cancelling a send, while a local operation (as defined by the MPI
|
||||
standard), is likely to be expensive (usually generating one or more internal
|
||||
messages).
|
||||
<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.
|
||||
<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
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<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.
|
||||
<P>
|
||||
<H2>Null Handles</H2>
|
||||
The MPI 1.1 specification, in the section on opaque objects, explicitly
|
||||
disallows freeing a null communicator. The text from the standard is:
|
||||
<PRE>
|
||||
A null handle argument is an erroneous IN argument in MPI calls, unless an
|
||||
exception is explicitly stated in the text that defines the function. Such
|
||||
exception is allowed for handles to request objects in Wait and Test calls
|
||||
(sections Communication Completion and Multiple Completions ). Otherwise, a
|
||||
null handle can only be passed to a function that allocates a new object and
|
||||
returns a reference to it in the handle.
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
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
|
||||
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
|
||||
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>
|
||||
<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>).
|
||||
</DL>
|
||||
</BODY></HTML>
|
||||
75
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Cart_coords.html
Normal file
75
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Cart_coords.html
Normal file
@@ -0,0 +1,75 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPI_Cart_coords</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPI_Cart_coords"><H1>MPI_Cart_coords</H1></A>
|
||||
Determines process coords in cartesian topology given rank in group
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
int MPI_Cart_coords(MPI_Comm comm, int rank, int maxdims, int coords[])
|
||||
</PRE>
|
||||
<H2>Input Parameters</H2>
|
||||
<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>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
|
||||
coordinates of specified process (integer)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
<P>
|
||||
This routine is both thread- and interrupt-safe.
|
||||
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
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<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.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
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
|
||||
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
|
||||
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_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>).
|
||||
</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>.
|
||||
</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>).
|
||||
</DL>
|
||||
</BODY></HTML>
|
||||
82
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Cart_create.html
Normal file
82
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Cart_create.html
Normal file
@@ -0,0 +1,82 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPI_Cart_create</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPI_Cart_create"><H1>MPI_Cart_create</H1></A>
|
||||
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)
|
||||
</PRE>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>comm_old </B><DD>input communicator (handle)
|
||||
|
||||
<DT><B>ndims </B><DD>number of dimensions of cartesian grid (integer)
|
||||
|
||||
<DT><B>dims </B><DD>integer array of size ndims specifying the number of processes in
|
||||
each dimension
|
||||
|
||||
<DT><B>periods </B><DD>logical array of size ndims specifying whether the grid is
|
||||
periodic (true) or not (false) in each dimension
|
||||
|
||||
<DT><B>reorder </B><DD>ranking may be reordered (true) or not (false) (logical)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL><DT><B>comm_cart </B> <DD> communicator with new cartesian topology (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Algorithm</H2>
|
||||
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.
|
||||
<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
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<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.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
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
|
||||
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
|
||||
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_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>).
|
||||
</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>).
|
||||
</DL>
|
||||
</BODY></HTML>
|
||||
78
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Cart_get.html
Normal file
78
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Cart_get.html
Normal file
@@ -0,0 +1,78 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPI_Cart_get</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPI_Cart_get"><H1>MPI_Cart_get</H1></A>
|
||||
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[])
|
||||
</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)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>dims </B><DD>number of processes for each cartesian dimension (array of integer)
|
||||
|
||||
<DT><B>periods </B><DD>periodicity (true/false) for each cartesian dimension
|
||||
(array of logical)
|
||||
|
||||
<DT><B>coords </B><DD>coordinates of calling process in cartesian structure
|
||||
(array of integer)
|
||||
</DL>
|
||||
<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.
|
||||
<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
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<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.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
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
|
||||
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
|
||||
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_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>).
|
||||
</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>).
|
||||
</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>).
|
||||
</DL>
|
||||
</BODY></HTML>
|
||||
74
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Cart_map.html
Normal file
74
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Cart_map.html
Normal file
@@ -0,0 +1,74 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPI_Cart_map</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPI_Cart_map"><H1>MPI_Cart_map</H1></A>
|
||||
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)
|
||||
</PRE>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>comm </B><DD>input communicator (handle)
|
||||
|
||||
<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
|
||||
each coordinate direction
|
||||
|
||||
<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
|
||||
calling process does not belong to grid (integer)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
<P>
|
||||
This routine is both thread- and interrupt-safe.
|
||||
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
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<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.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
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
|
||||
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
|
||||
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>).
|
||||
</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>).
|
||||
</DL>
|
||||
</BODY></HTML>
|
||||
76
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Cart_rank.html
Normal file
76
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Cart_rank.html
Normal file
@@ -0,0 +1,76 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPI_Cart_rank</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPI_Cart_rank"><H1>MPI_Cart_rank</H1></A>
|
||||
Determines process rank in communicator given Cartesian location
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
int MPI_Cart_rank(MPI_Comm comm, const int coords[], int *rank)
|
||||
</PRE>
|
||||
<H2>Input Parameters</H2>
|
||||
<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
|
||||
coordinates of a process
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL><DT><B>rank </B> <DD> rank of specified process (integer)
|
||||
</DL>
|
||||
<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
|
||||
case.
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
<P>
|
||||
This routine is both thread- and interrupt-safe.
|
||||
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
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<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.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
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
|
||||
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
|
||||
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_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>).
|
||||
</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>.
|
||||
</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>).
|
||||
</DL>
|
||||
</BODY></HTML>
|
||||
77
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Cart_shift.html
Normal file
77
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Cart_shift.html
Normal file
@@ -0,0 +1,77 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPI_Cart_shift</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPI_Cart_shift"><H1>MPI_Cart_shift</H1></A>
|
||||
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)
|
||||
</PRE>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>comm </B><DD>communicator with cartesian structure (handle)
|
||||
|
||||
<DT><B>direction </B><DD>coordinate dimension of shift (integer)
|
||||
|
||||
<DT><B>disp </B><DD>displacement (> 0: upwards shift, < 0: downwards shift) (integer)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>rank_source </B><DD>rank of source process (integer)
|
||||
|
||||
<DT><B>rank_dest </B><DD>rank of destination process (integer)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Notes</H2>
|
||||
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>
|
||||
<P>
|
||||
This routine is both thread- and interrupt-safe.
|
||||
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
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<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.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
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
|
||||
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
|
||||
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_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>).
|
||||
</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>).
|
||||
</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>).
|
||||
</DL>
|
||||
</BODY></HTML>
|
||||
73
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Cart_sub.html
Normal file
73
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Cart_sub.html
Normal file
@@ -0,0 +1,73 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPI_Cart_sub</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPI_Cart_sub"><H1>MPI_Cart_sub</H1></A>
|
||||
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)
|
||||
</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
|
||||
dimension is kept in the subgrid (true) or is dropped (false) (logical
|
||||
vector)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL><DT><B>newcomm </B> <DD> communicator containing the subgrid that includes the calling
|
||||
process (handle)
|
||||
</DL>
|
||||
<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.
|
||||
<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
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<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.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
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
|
||||
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
|
||||
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_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>).
|
||||
</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>).
|
||||
</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>).
|
||||
</DL>
|
||||
</BODY></HTML>
|
||||
61
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Cartdim_get.html
Normal file
61
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Cartdim_get.html
Normal file
@@ -0,0 +1,61 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPI_Cartdim_get</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPI_Cartdim_get"><H1>MPI_Cartdim_get</H1></A>
|
||||
Retrieves Cartesian topology information associated with a communicator
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
int MPI_Cartdim_get(MPI_Comm comm, int *ndims)
|
||||
</PRE>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL><DT><B>comm </B> <DD> communicator with cartesian structure (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL><DT><B>ndims </B> <DD> number of dimensions of the cartesian structure (integer)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
<P>
|
||||
This routine is both thread- and interrupt-safe.
|
||||
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
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<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.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
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
|
||||
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
|
||||
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>).
|
||||
</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>).
|
||||
</DL>
|
||||
</BODY></HTML>
|
||||
58
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Close_port.html
Normal file
58
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Close_port.html
Normal file
@@ -0,0 +1,58 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPI_Close_port</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPI_Close_port"><H1>MPI_Close_port</H1></A>
|
||||
close port
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
int MPI_Close_port(const char *port_name)
|
||||
</PRE>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL><DT><B>port_name </B> <DD> a port name (string)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
<P>
|
||||
The user is responsible for ensuring that multiple threads do not try to
|
||||
update the same MPI object from different threads. This routine should
|
||||
not be used from within a signal handler.
|
||||
<P>
|
||||
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
|
||||
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
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<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.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
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
|
||||
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
|
||||
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>
|
||||
</BODY></HTML>
|
||||
70
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Comm_accept.html
Normal file
70
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Comm_accept.html
Normal file
@@ -0,0 +1,70 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPI_Comm_accept</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPI_Comm_accept"><H1>MPI_Comm_accept</H1></A>
|
||||
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)
|
||||
</PRE>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>port_name </B><DD>port name (string, used only on root)
|
||||
|
||||
<DT><B>info </B><DD>implementation-dependent information (handle, used only on root)
|
||||
|
||||
<DT><B>root </B><DD>rank in comm of root node (integer)
|
||||
|
||||
<DT><B>comm </B><DD>intracommunicator over which call is collective (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL><DT><B>newcomm </B> <DD> intercommunicator with client as remote group (handle)
|
||||
</DL>
|
||||
<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.
|
||||
<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
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<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.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
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
|
||||
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
|
||||
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_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>).
|
||||
</DL>
|
||||
</BODY></HTML>
|
||||
@@ -0,0 +1,70 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPI_Comm_call_errhandler</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPI_Comm_call_errhandler"><H1>MPI_Comm_call_errhandler</H1></A>
|
||||
Call the error handler installed on a communicator
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
int MPI_Comm_call_errhandler(MPI_Comm comm, int errorcode)
|
||||
</PRE>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>comm </B><DD>communicator with error handler (handle)
|
||||
|
||||
<DT><B>errorcode </B><DD>error code (integer)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Note</H2>
|
||||
Assuming the input parameters are valid, when the error handler is set to
|
||||
MPI_ERRORS_RETURN, this routine will always return MPI_SUCCESS.
|
||||
<P>
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
<P>
|
||||
This routine is thread and interrupt safe only if no MPI routine that
|
||||
updates or frees the same MPI object may be called concurrently
|
||||
with this routine.
|
||||
<P>
|
||||
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
|
||||
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
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<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.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
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
|
||||
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
|
||||
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>).
|
||||
</DL>
|
||||
</BODY></HTML>
|
||||
80
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Comm_compare.html
Normal file
80
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Comm_compare.html
Normal file
@@ -0,0 +1,80 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPI_Comm_compare</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPI_Comm_compare"><H1>MPI_Comm_compare</H1></A>
|
||||
Compares two communicators
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
int MPI_Comm_compare(MPI_Comm comm1, MPI_Comm comm2, int *result)
|
||||
</PRE>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>comm1 </B><DD>comm1 (handle)
|
||||
|
||||
<DT><B>comm2 </B><DD>comm2 (handle)
|
||||
</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>
|
||||
<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
|
||||
<P>
|
||||
.(2.4.1 Opaque Objects)
|
||||
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.
|
||||
<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.
|
||||
(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
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<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.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
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
|
||||
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
|
||||
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>).
|
||||
</DL>
|
||||
</BODY></HTML>
|
||||
72
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Comm_connect.html
Normal file
72
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Comm_connect.html
Normal file
@@ -0,0 +1,72 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPI_Comm_connect</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPI_Comm_connect"><H1>MPI_Comm_connect</H1></A>
|
||||
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)
|
||||
</PRE>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>port_name </B><DD>network address (string, used only on root)
|
||||
|
||||
<DT><B>info </B><DD>implementation-dependent information (handle, used only on root)
|
||||
|
||||
<DT><B>root </B><DD>rank in comm of root node (integer)
|
||||
|
||||
<DT><B>comm </B><DD>intracommunicator over which call is collective (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL><DT><B>newcomm </B> <DD> intercommunicator with server as remote group (handle)
|
||||
</DL>
|
||||
<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.
|
||||
<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
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<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.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
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
|
||||
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
|
||||
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>).
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_INFO </B> <DD> Invalid Info
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_PORT </B> <DD>
|
||||
</DL>
|
||||
</BODY></HTML>
|
||||
69
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Comm_create.html
Normal file
69
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Comm_create.html
Normal file
@@ -0,0 +1,69 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPI_Comm_create</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPI_Comm_create"><H1>MPI_Comm_create</H1></A>
|
||||
Creates a new communicator
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
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)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL><DT><B>newcomm </B> <DD> new communicator (handle)
|
||||
</DL>
|
||||
<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.
|
||||
<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
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<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.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
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
|
||||
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
|
||||
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>).
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_GROUP </B> <DD> Null or invalid group passed to function.
|
||||
</DL>
|
||||
<P>
|
||||
<H2>See Also</H2>
|
||||
MPI_Comm_free
|
||||
<BR>
|
||||
</BODY></HTML>
|
||||
@@ -0,0 +1,69 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPI_Comm_create_errhandler</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPI_Comm_create_errhandler"><H1>MPI_Comm_create_errhandler</H1></A>
|
||||
Create a communicator error handler
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
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)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL><DT><B>errhandler </B> <DD> MPI error handler (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Error Handler</H2>
|
||||
The error handler function should be of the form
|
||||
<P>
|
||||
void MPI_Comm_errhandler_function(MPI_Comm *comm, int *rc);
|
||||
<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.
|
||||
<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
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<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.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
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
|
||||
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
|
||||
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>).
|
||||
</DL>
|
||||
<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>
|
||||
@@ -0,0 +1,71 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPI_Comm_create_group</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPI_Comm_create_group"><H1>MPI_Comm_create_group</H1></A>
|
||||
Creates a new communicator
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
int MPI_Comm_create_group(MPI_Comm comm, MPI_Group group, int tag, 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>tag </B><DD>safe tag unused by other communication
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL><DT><B>newcomm </B> <DD> new communicator (handle)
|
||||
</DL>
|
||||
<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.
|
||||
<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
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<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.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
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
|
||||
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
|
||||
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>).
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_GROUP </B> <DD> Null or invalid group passed to function.
|
||||
</DL>
|
||||
<P>
|
||||
<H2>See Also</H2>
|
||||
MPI_Comm_free
|
||||
<BR>
|
||||
</BODY></HTML>
|
||||
@@ -0,0 +1,94 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPI_Comm_create_keyval</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPI_Comm_create_keyval"><H1>MPI_Comm_create_keyval</H1></A>
|
||||
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 *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>extra_state </B><DD>Extra state for callback functions
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL><DT><B>comm_keyval </B> <DD> key value for future access (integer)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Notes</H2>
|
||||
Key values are global (available for any and all communicators).
|
||||
<P>
|
||||
Default copy and delete functions are available. These are
|
||||
<DL>
|
||||
<DT><B>MPI_COMM_NULL_COPY_FN </B><DD>empty copy function
|
||||
|
||||
<DT><B>MPI_COMM_NULL_DELETE_FN </B><DD>empty delete function
|
||||
|
||||
<DT><B>MPI_COMM_DUP_FN </B><DD>simple dup function
|
||||
</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.
|
||||
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.
|
||||
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
|
||||
user to define and use MPI error codes and classes.
|
||||
<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.
|
||||
<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
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<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.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
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
|
||||
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
|
||||
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>
|
||||
<H2>See Also</H2>
|
||||
MPI_Comm_free_keyval
|
||||
<BR>
|
||||
</BODY></HTML>
|
||||
@@ -0,0 +1,66 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPI_Comm_delete_attr</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPI_Comm_delete_attr"><H1>MPI_Comm_delete_attr</H1></A>
|
||||
Deletes an attribute value associated with a key on a communicator
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
int MPI_Comm_delete_attr(MPI_Comm comm, int comm_keyval)
|
||||
</PRE>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>comm </B><DD>communicator to which attribute is attached (handle)
|
||||
|
||||
<DT><B>comm_keyval </B><DD>The key value of the deleted attribute (integer)
|
||||
</DL>
|
||||
<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.
|
||||
<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
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<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.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
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
|
||||
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
|
||||
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>).
|
||||
</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>
|
||||
<H2>See Also</H2>
|
||||
MPI_Comm_set_attr, MPI_Comm_create_keyval
|
||||
<BR>
|
||||
</BODY></HTML>
|
||||
@@ -0,0 +1,62 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPI_Comm_disconnect</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPI_Comm_disconnect"><H1>MPI_Comm_disconnect</H1></A>
|
||||
Disconnect from a communicator
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
int MPI_Comm_disconnect(MPI_Comm * comm)
|
||||
</PRE>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL><DT><B>comm </B> <DD> communicator (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Notes</H2>
|
||||
This routine waits for all pending communication to complete, then frees the
|
||||
communicator and sets <TT>comm</TT> to <TT>MPI_COMM_NULL</TT>. It may not be called
|
||||
with <TT>MPI_COMM_WORLD</TT> or <TT>MPI_COMM_SELF</TT>.
|
||||
<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.
|
||||
<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
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<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.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
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
|
||||
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
|
||||
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>
|
||||
<H2>See Also</H2>
|
||||
MPI_Comm_connect, MPI_Comm_join
|
||||
<BR>
|
||||
</BODY></HTML>
|
||||
87
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Comm_dup.html
Normal file
87
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Comm_dup.html
Normal file
@@ -0,0 +1,87 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPI_Comm_dup</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPI_Comm_dup"><H1>MPI_Comm_dup</H1></A>
|
||||
Duplicates an existing communicator with all its cached information
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
int MPI_Comm_dup(MPI_Comm comm, MPI_Comm * newcomm)
|
||||
</PRE>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL><DT><B>comm </B> <DD> Communicator to be duplicated (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL><DT><B>newcomm </B> <DD> A new communicator over the same group as <TT>comm</TT> but with a new
|
||||
context. See notes. (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Notes</H2>
|
||||
This routine is used to create a new communicator that has a new
|
||||
communication context but contains the same group of processes as
|
||||
the input communicator. Since all MPI communication is performed
|
||||
within a communicator (specifies as the group of processes <EM>plus
|
||||
</EM>the context), this routine provides an effective way to create a
|
||||
private communicator for use by a software module or library. In
|
||||
particular, no library routine should use <TT>MPI_COMM_WORLD</TT> as the
|
||||
communicator; instead, a duplicate of a user-specified communicator
|
||||
should always be used. For more information, see Using MPI, 2nd
|
||||
edition.
|
||||
<P>
|
||||
Because this routine essentially produces a copy of a communicator,
|
||||
it also copies any attributes that have been defined on the input
|
||||
communicator, using the attribute copy function specified by the
|
||||
<TT>copy_function</TT> argument to <TT>MPI_Keyval_create</TT>. This is
|
||||
particularly useful for (a) attributes that describe some property
|
||||
of the group associated with the communicator, such as its
|
||||
interconnection topology and (b) communicators that are given back
|
||||
to the user; the attibutes in this case can track subsequent
|
||||
<TT>MPI_Comm_dup</TT> operations on this communicator.
|
||||
<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.
|
||||
<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
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<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.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
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
|
||||
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
|
||||
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>).
|
||||
</DL>
|
||||
<P>
|
||||
<H2>See Also</H2>
|
||||
MPI_Comm_free, MPI_Keyval_create, MPI_Attr_put, MPI_Attr_delete,
|
||||
<BR>MPI_Comm_create_keyval, MPI_Comm_set_attr, MPI_Comm_delete_attr
|
||||
</BODY></HTML>
|
||||
@@ -0,0 +1,75 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPI_Comm_dup_with_info</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPI_Comm_dup_with_info"><H1>MPI_Comm_dup_with_info</H1></A>
|
||||
Duplicates an existing communicator with all its cached information
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
int MPI_Comm_dup_with_info(MPI_Comm comm, MPI_Info info, MPI_Comm * newcomm)
|
||||
</PRE>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>comm </B><DD>Communicator to be duplicated (handle)
|
||||
|
||||
<DT><B>info </B><DD>info object (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL><DT><B>newcomm </B> <DD> A new communicator over the same group as <TT>comm</TT> but with a new
|
||||
context. See notes. (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Notes</H2>
|
||||
MPI_COMM_DUP_WITH_INFO behaves exactly as MPI_COMM_DUP except that
|
||||
the info hints associated with the communicator comm are not
|
||||
duplicated in newcomm. The hints provided by the argument info are
|
||||
associated with the output communicator newcomm instead.
|
||||
<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.
|
||||
<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
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<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.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
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
|
||||
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
|
||||
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>).
|
||||
</DL>
|
||||
<P>
|
||||
<H2>See Also</H2>
|
||||
MPI_Comm_dup, MPI_Comm_free, MPI_Keyval_create,
|
||||
<BR>MPI_Attr_put, MPI_Attr_delete, MPI_Comm_create_keyval,
|
||||
MPI_Comm_set_attr, MPI_Comm_delete_attr
|
||||
</BODY></HTML>
|
||||
79
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Comm_free.html
Normal file
79
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Comm_free.html
Normal file
@@ -0,0 +1,79 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPI_Comm_free</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPI_Comm_free"><H1>MPI_Comm_free</H1></A>
|
||||
Marks the communicator object for deallocation
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
int MPI_Comm_free(MPI_Comm * comm)
|
||||
</PRE>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL><DT><B>comm </B> <DD> Communicator to be destroyed (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Notes</H2>
|
||||
This routine <EM>frees</EM> a communicator. Because the communicator may still
|
||||
be in use by other MPI routines, the actual communicator storage will not
|
||||
be freed until all references to this communicator are removed. For most
|
||||
users, the effect of this routine is the same as if it was in fact freed
|
||||
at this time of this call.
|
||||
<P>
|
||||
<H2>Null Handles</H2>
|
||||
The MPI 1.1 specification, in the section on opaque objects, explicitly
|
||||
<H2>disallows freeing a null communicator. The text from the standard is</H2>
|
||||
<PRE>
|
||||
A null handle argument is an erroneous IN argument in MPI calls, unless an
|
||||
exception is explicitly stated in the text that defines the function. Such
|
||||
exception is allowed for handles to request objects in Wait and Test calls
|
||||
(sections Communication Completion and Multiple Completions). Otherwise, a
|
||||
null handle can only be passed to a function that allocates a new object and
|
||||
returns a reference to it in the handle.
|
||||
</PRE>
|
||||
|
||||
<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.
|
||||
<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
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<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.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
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
|
||||
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
|
||||
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>).
|
||||
</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>).
|
||||
</DL>
|
||||
</BODY></HTML>
|
||||
@@ -0,0 +1,62 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPI_Comm_free_keyval</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPI_Comm_free_keyval"><H1>MPI_Comm_free_keyval</H1></A>
|
||||
Frees an attribute key for communicators
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
int MPI_Comm_free_keyval(int *comm_keyval)
|
||||
</PRE>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL><DT><B>comm_keyval </B> <DD> Frees the integer key value (integer)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Notes</H2>
|
||||
Key values are global (they can be used with any and all communicators)
|
||||
<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.
|
||||
<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
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<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.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
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
|
||||
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
|
||||
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>).
|
||||
</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>
|
||||
</BODY></HTML>
|
||||
79
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Comm_get_attr.html
Normal file
79
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Comm_get_attr.html
Normal file
@@ -0,0 +1,79 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPI_Comm_get_attr</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPI_Comm_get_attr"><H1>MPI_Comm_get_attr</H1></A>
|
||||
Retrieves attribute value by key
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
int MPI_Comm_get_attr(MPI_Comm comm, int comm_keyval, void *attribute_val, int *flag)
|
||||
</PRE>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>comm </B><DD>communicator to which attribute is attached (handle)
|
||||
|
||||
<DT><B>comm_keyval </B><DD>key value (integer)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL>
|
||||
<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
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Notes</H2>
|
||||
Attributes must be extracted from the same language as they were inserted
|
||||
in with <TT>MPI_Comm_set_attr</TT>. The notes for C and Fortran below explain
|
||||
why.
|
||||
<P>
|
||||
<H2>Notes for C</H2>
|
||||
Even though the <TT>attr_value</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>
|
||||
<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.
|
||||
<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
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<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.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
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
|
||||
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
|
||||
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>).
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_KEYVAL </B> <DD> Invalid keyval
|
||||
</DL>
|
||||
</BODY></HTML>
|
||||
@@ -0,0 +1,67 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPI_Comm_get_errhandler</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPI_Comm_get_errhandler"><H1>MPI_Comm_get_errhandler</H1></A>
|
||||
Get the error handler attached to a communicator
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
int MPI_Comm_get_errhandler(MPI_Comm comm, MPI_Errhandler * errhandler)
|
||||
</PRE>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL><DT><B>comm </B> <DD> communicator (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL><DT><B>errhandler </B> <DD> handler currently associated with communicator (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
<P>
|
||||
This routine is thread and interrupt safe only if no MPI routine that
|
||||
updates or frees the same MPI object may be called concurrently
|
||||
with this routine.
|
||||
<P>
|
||||
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
|
||||
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
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<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.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
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
|
||||
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
|
||||
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>).
|
||||
</DL>
|
||||
</BODY></HTML>
|
||||
64
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Comm_get_info.html
Normal file
64
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Comm_get_info.html
Normal file
@@ -0,0 +1,64 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPI_Comm_get_info</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPI_Comm_get_info"><H1>MPI_Comm_get_info</H1></A>
|
||||
Returns a new info object containing the hints of the communicator associated with comm. The current setting of all hints actually used by the system related to this communicator is returned in info_used. If no such hints exist, a handle to a newly created info object is returned that contains no key/value pair. The user is responsible for freeing info_used via MPI_INFO_FREE.
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
int MPI_Comm_get_info(MPI_Comm comm, MPI_Info * info_used)
|
||||
</PRE>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL><DT><B>comm </B> <DD> communicator object (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL><DT><B>info_used </B> <DD> new info argument (handle)
|
||||
</DL>
|
||||
<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.
|
||||
<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
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<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.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
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
|
||||
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
|
||||
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>).
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_INFO </B> <DD> Invalid Info
|
||||
</DL>
|
||||
<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>
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user