libmpiwrap.c revision b32f58018498ea2225959b0ba11c18f0c433deef
1ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 2ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*---------------------------------------------------------------*/ 3ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*--- ---*/ 4ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*--- A library of wrappers for MPI 2 functions. ---*/ 5ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*--- ---*/ 6ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*---------------------------------------------------------------*/ 7ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 8ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* ---------------------------------------------------------------- 9ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 10ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Notice that the following BSD-style license applies to this one 11ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown file (mpiwrap.c) only. The rest of Valgrind is licensed under the 12ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown terms of the GNU General Public License, version 2, unless 13ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown otherwise indicated. See the COPYING file in the source 14ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown distribution for details. 15ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 16ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown ---------------------------------------------------------------- 17ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 18ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown This file is part of Valgrind, a dynamic binary instrumentation 19ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown framework. 20ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 21b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov Copyright (C) 2006-2011 OpenWorks LLP. All rights reserved. 22ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 23ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Redistribution and use in source and binary forms, with or without 24ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown modification, are permitted provided that the following conditions 25ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown are met: 26ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 27ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1. Redistributions of source code must retain the above copyright 28ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown notice, this list of conditions and the following disclaimer. 29ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 30ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 2. The origin of this software must not be misrepresented; you must 31ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown not claim that you wrote the original software. If you use this 32ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown software in a product, an acknowledgment in the product 33ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown documentation would be appreciated but is not required. 34ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 35ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 3. Altered source versions must be plainly marked as such, and must 36ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown not be misrepresented as being the original software. 37ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 38ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 4. The name of the author may not be used to endorse or promote 39ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown products derived from this software without specific prior written 40ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown permission. 41ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 42ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS 43ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 44ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 45ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY 46ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 47ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE 48ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 49ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 50ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 51ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 52ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 53ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 54ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Neither the names of the U.S. Department of Energy nor the 55ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown University of California nor the names of its contributors may be 56ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown used to endorse or promote products derived from this software 57ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown without prior written permission. 58ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown*/ 59ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 60ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* Handling of MPI_STATUS{ES}_IGNORE for MPI_Status* arguments. 61ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 62ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown The MPI-2 spec allows many functions which have MPI_Status* purely 63ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown as an out parameter, to accept the constants MPI_STATUS_IGNORE or 64ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown MPI_STATUSES_IGNORE there instead, if the caller does not care 65ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown about the status. See the MPI-2 spec sec 4.5.1 ("Passing 66ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown MPI_STATUS_IGNORE for Status"). (mpi2-report.pdf, 1615898 bytes, 67ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown md5=694a5efe2fd291eecf7e8c9875b5f43f). 68ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 69ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown This library handles such cases by allocating a fake MPI_Status 70ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown object (on the stack) or an array thereof (on the heap), and 71ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown passing that onwards instead. From the outside the caller sees no 72ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown difference. Unfortunately the simpler approach of merely detecting 73ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown and handling these special cases at a lower level does not work, 74ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown because we need to use information returned in MPI_Status* 75ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown arguments to paint result buffers, even if the caller doesn't 76ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown supply a real MPI_Status object. 77ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 78ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Eg, MPI_Recv. We can't paint the result buffer without knowing how 79ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown many items arrived; but we can't find that out without passing a 80ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown real MPI_Status object to the (real) MPI_Recv call. Hence, if the 81ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown caller did not supply one, we have no option but to use a temporary 82ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown stack allocated one for the inner call. Ditto, more indirectly 83ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown (via maybe_complete) for nonblocking receives and the various 84ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown associated wait/test calls. */ 85ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 86ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 87ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*------------------------------------------------------------*/ 88ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*--- includes ---*/ 89ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*------------------------------------------------------------*/ 90ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 91ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown#include <stdio.h> 92ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown#include <assert.h> 93ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown#include <unistd.h> /* getpid */ 94ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown#include <stdlib.h> /* exit */ 95ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown#include <string.h> /* strstr */ 96ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown#include <pthread.h> /* pthread_mutex_{lock,unlock} */ 97ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 98ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* Include Valgrind magic macros for writing wrappers. */ 99ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown#include "../memcheck/memcheck.h" 100ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 101b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov/* Include macros for VALGRIND_{DIS,EN}ABLE_ERROR_REPORTING. 102b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov This is somewhat experimental and hence disable-able, by 103b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov setting cONFIG_DER to zero. */ 104b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov#include "../include/valgrind.h" 105b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov 106b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov#define cONFIG_DER 1 /* set to 0 to disable */ 107b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov 108ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 109ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*------------------------------------------------------------*/ 110ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*--- Connect to MPI library ---*/ 111ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*------------------------------------------------------------*/ 112ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 113ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* Include headers for whatever MPI implementation the wrappers are to 114ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown be used with. The configure system will tell us what the path to 115ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown the chosen MPI implementation is, via -I.. to the compiler. */ 116ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown#include "mpi.h" 117ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 118ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* Where are API symbols? 119ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Open MPI lib/libmpi.so, soname = libmpi.so.0 120ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Quadrics MPI lib/libmpi.so, soname = libmpi.so.0 121ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown MPICH libmpich.so.1.0, soname = libmpich.so.1.0 122ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 123b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov A suitable soname to match with is therefore "libmpi*.so*". 124ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown*/ 125b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov#define I_WRAP_FNNAME_U(_name) \ 126b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov I_WRAP_SONAME_FNNAME_ZU(libmpiZaZdsoZa,_name) 127ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 128ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 129ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* Define HAVE_MPI_STATUS_IGNORE iff we have to deal with 130ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown MPI_STATUS{ES}_IGNORE. */ 131ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown#if MPI_VERSION >= 2 \ 132ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown || (defined(MPI_STATUS_IGNORE) && defined(MPI_STATUSES_IGNORE)) 133ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# undef HAVE_MPI_STATUS_IGNORE 134ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# define HAVE_MPI_STATUS_IGNORE 1 135ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown#else 136ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# undef HAVE_MPI_STATUS_IGNORE 137ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown#endif 138ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 139ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 140ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*------------------------------------------------------------*/ 141ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*--- Decls ---*/ 142ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*------------------------------------------------------------*/ 143ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 144ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Browntypedef unsigned char Bool; 145ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown#define False ((Bool)0) 146ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown#define True ((Bool)1) 147ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 148ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* Word, UWord are machine words - same size as a pointer. This is 149ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown checked at startup. The wrappers below use 'long' to mean a 150ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown machine word - this too is tested at startup. */ 151ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Browntypedef signed long Word; 152ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Browntypedef unsigned long UWord; 153ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 154ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown#if !defined(offsetof) 155ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# define offsetof(type,memb) ((int)&((type*)0)->memb) 156ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown#endif 157ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 158ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* Find the size of long double image (not 'sizeof(long double)'). 159ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown See comments in sizeofOneNamedTy. */ 160ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownstatic long sizeof_long_double_image ( void ); 161ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 162ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 163ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*------------------------------------------------------------*/ 164ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*--- Simple helpers ---*/ 165ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*------------------------------------------------------------*/ 166ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 167ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* ------ Helpers for debug printing ------ */ 168ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 169ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* constant */ 170ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownstatic const char* preamble = "valgrind MPI wrappers"; 171ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 172ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* established at startup */ 173ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownstatic pid_t my_pid = -1; 174ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownstatic char* options_str = NULL; 175ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownstatic int opt_verbosity = 1; 176ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownstatic Bool opt_missing = 0; /* 0:silent; 1:warn; 2:abort */ 177ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownstatic Bool opt_help = False; 178ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownstatic Bool opt_initkludge = False; 179ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 180ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownstatic void before ( char* fnname ) 181ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown{ 182ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown /* This isn't thread-safe wrt 'done' (no locking). It's not 183ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown critical. */ 184ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown static int done = 0; 185ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (done == 0) { 186ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown done = 1; 187ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown my_pid = getpid(); 188ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown options_str = getenv("MPIWRAP_DEBUG"); 189ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (options_str) { 190ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (NULL != strstr(options_str, "warn")) 191ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown opt_missing = 1; 192ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (NULL != strstr(options_str, "strict")) 193ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown opt_missing = 2; 194ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (NULL != strstr(options_str, "verbose")) 195ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown opt_verbosity++; 196ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (NULL != strstr(options_str, "quiet")) 197ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown opt_verbosity--; 198ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (NULL != strstr(options_str, "help")) 199ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown opt_help = True; 200ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (NULL != strstr(options_str, "initkludge")) 201ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown opt_initkludge = True; 202ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 203ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (opt_verbosity > 0) 204ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown fprintf(stderr, "%s %5d: Active for pid %d\n", 205ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown preamble, my_pid, my_pid); 206ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown /* Sanity check - that Word/UWord really are machine words. */ 207ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown assert(sizeof(Word) == sizeof(void*)); 208ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown assert(sizeof(UWord) == sizeof(void*)); 209ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown /* Sanity check - char is byte-sized (else address calculations 210ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown in walk_type don't work. */ 211ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown assert(sizeof(char) == 1); 212ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (opt_help) { 213ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown fprintf(stderr, "\n"); 214ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown fprintf(stderr, "Valid options for the MPIWRAP_DEBUG environment" 215ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown " variable are:\n"); 216ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown fprintf(stderr, "\n"); 217ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown fprintf(stderr, " quiet be silent except for errors\n"); 218ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown fprintf(stderr, " verbose show wrapper entries/exits\n"); 219ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown fprintf(stderr, " strict abort the program if a function" 220ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown " with no wrapper is used\n"); 221ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown fprintf(stderr, " warn give a warning if a function" 222ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown " with no wrapper is used\n"); 223ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown fprintf(stderr, " help display this message, then exit\n"); 224ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown fprintf(stderr, " initkludge debugging hack; do not use\n"); 225ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown fprintf(stderr, "\n"); 226ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown fprintf(stderr, "Multiple options are allowed, eg" 227ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown " MPIWRAP_DEBUG=strict,verbose\n"); 228ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown fprintf(stderr, "Note: 'warn' generates output even if 'quiet'" 229ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown " is also specified\n"); 230ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown fprintf(stderr, "\n"); 231ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown fprintf(stderr, "%s %5d: exiting now\n", preamble, my_pid ); 232ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown exit(1); 233ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 234ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (opt_verbosity > 0) 235ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown fprintf(stderr, 236ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown "%s %5d: Try MPIWRAP_DEBUG=help for possible options\n", 237ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown preamble, my_pid); 238ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 239ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 240ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (opt_verbosity > 1) 241ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown fprintf(stderr, "%s %5d: enter PMPI_%s\n", preamble, my_pid, fnname ); 242ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 243ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 244ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownstatic __inline__ void after ( char* fnname, int err ) 245ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown{ 246ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (opt_verbosity > 1) 247ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown fprintf(stderr, "%s %5d: exit PMPI_%s (err = %d)\n", 248ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown preamble, my_pid, fnname, err ); 249ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 250ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 251ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownstatic void barf ( char* msg ) 252ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown{ 253ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown fprintf(stderr, "%s %5d: fatal: %s\n", preamble, my_pid, msg); 254ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown fprintf(stderr, "%s %5d: exiting now\n", preamble, my_pid ); 255ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown exit(1); 256ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 257ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 258ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* Half-hearted type-showing function (for debugging). */ 259ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownstatic void showTy ( FILE* f, MPI_Datatype ty ) 260ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown{ 261ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (ty == MPI_DATATYPE_NULL) fprintf(f,"DATATYPE_NULL"); 262ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown else if (ty == MPI_BYTE) fprintf(f,"BYTE"); 263ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown else if (ty == MPI_PACKED) fprintf(f,"PACKED"); 264ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown else if (ty == MPI_CHAR) fprintf(f,"CHAR"); 265ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown else if (ty == MPI_SHORT) fprintf(f,"SHORT"); 266ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown else if (ty == MPI_INT) fprintf(f,"INT"); 267ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown else if (ty == MPI_LONG) fprintf(f,"LONG"); 268ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown else if (ty == MPI_FLOAT) fprintf(f,"FLOAT"); 269ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown else if (ty == MPI_DOUBLE) fprintf(f,"DOUBLE"); 270ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown else if (ty == MPI_LONG_DOUBLE) fprintf(f,"LONG_DOUBLE"); 271ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown else if (ty == MPI_UNSIGNED_CHAR) fprintf(f,"UNSIGNED_CHAR"); 272ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown else if (ty == MPI_UNSIGNED_SHORT) fprintf(f,"UNSIGNED_SHORT"); 273ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown else if (ty == MPI_UNSIGNED_LONG) fprintf(f,"UNSIGNED_LONG"); 274ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown else if (ty == MPI_UNSIGNED) fprintf(f,"UNSIGNED"); 275ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown else if (ty == MPI_FLOAT_INT) fprintf(f,"FLOAT_INT"); 276ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown else if (ty == MPI_DOUBLE_INT) fprintf(f,"DOUBLE_INT"); 277ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown else if (ty == MPI_LONG_DOUBLE_INT) fprintf(f,"LONG_DOUBLE_INT"); 278ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown else if (ty == MPI_LONG_INT) fprintf(f,"LONG_INT"); 279ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown else if (ty == MPI_SHORT_INT) fprintf(f,"SHORT_INT"); 280ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown else if (ty == MPI_2INT) fprintf(f,"2INT"); 281ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown else if (ty == MPI_UB) fprintf(f,"UB"); 282ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown else if (ty == MPI_LB) fprintf(f,"LB"); 283ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# if defined(MPI_WCHAR) 284ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown else if (ty == MPI_WCHAR) fprintf(f,"WCHAR"); 285ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# endif 286ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown else if (ty == MPI_LONG_LONG_INT) fprintf(f,"LONG_LONG_INT"); 287ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# if defined(MPI_LONG_LONG) 288ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown else if (ty == MPI_LONG_LONG) fprintf(f,"LONG_LONG"); 289ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# endif 290ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# if defined(MPI_UNSIGNED_LONG_LONG) 291ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown else if (ty == MPI_UNSIGNED_LONG_LONG) fprintf(f,"UNSIGNED_LONG_LONG"); 292ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# endif 293ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# if defined(MPI_REAL8) 294ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown else if (ty == MPI_REAL8) fprintf(f, "REAL8"); 295ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# endif 296ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# if defined(MPI_REAL4) 297ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown else if (ty == MPI_REAL4) fprintf(f, "REAL4"); 298ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# endif 299ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# if defined(MPI_REAL) 300ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown else if (ty == MPI_REAL) fprintf(f, "REAL"); 301ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# endif 302ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# if defined(MPI_INTEGER8) 303ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown else if (ty == MPI_INTEGER8) fprintf(f, "INTEGER8"); 304ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# endif 305ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# if defined(MPI_INTEGER4) 306ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown else if (ty == MPI_INTEGER4) fprintf(f, "INTEGER4"); 307ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# endif 308ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# if defined(MPI_INTEGER) 309ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown else if (ty == MPI_INTEGER) fprintf(f, "INTEGER"); 310ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# endif 311ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# if defined(MPI_DOUBLE_PRECISION) 312ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown else if (ty == MPI_DOUBLE_PRECISION) fprintf(f, "DOUBLE_PRECISION"); 313ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# endif 314ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# if defined(MPI_COMPLEX) 315ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown else if (ty == MPI_COMPLEX) fprintf(f, "COMPLEX"); 316ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# endif 317ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# if defined(MPI_DOUBLE_COMPLEX) 318ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown else if (ty == MPI_DOUBLE_COMPLEX) fprintf(f, "DOUBLE_COMPLEX"); 319ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# endif 320ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# if defined(MPI_LOGICAL) 321ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown else if (ty == MPI_LOGICAL) fprintf(f, "LOGICAL"); 322ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# endif 323ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# if defined(MPI_2INTEGER) 324ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown else if (ty == MPI_2INTEGER) fprintf(f, "2INTEGER"); 325ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# endif 326ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# if defined(MPI_2COMPLEX) 327ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown else if (ty == MPI_2COMPLEX) fprintf(f, "2COMPLEX"); 328ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# endif 329ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# if defined(MPI_2DOUBLE_COMPLEX) 330ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown else if (ty == MPI_2DOUBLE_COMPLEX) fprintf(f, "2DOUBLE_COMPLEX"); 331ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# endif 332ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# if defined(MPI_2REAL) 333ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown else if (ty == MPI_2REAL) fprintf(f, "2REAL"); 334ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# endif 335ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# if defined(MPI_2DOUBLE_PRECISION) 336ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown else if (ty == MPI_2DOUBLE_PRECISION) fprintf(f, "2DOUBLE_PRECISION"); 337ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# endif 338ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# if defined(MPI_CHARACTER) 339ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown else if (ty == MPI_CHARACTER) fprintf(f, "CHARACTER"); 340ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# endif 341ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown else fprintf(f,"showTy:???"); 342ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 343ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 344ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownstatic void showCombiner ( FILE* f, int combiner ) 345ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown{ 346ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown switch (combiner) { 347ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case MPI_COMBINER_NAMED: fprintf(f, "NAMED"); break; 348ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown#if defined(MPI_COMBINER_DUP) 349ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case MPI_COMBINER_DUP: fprintf(f, "DUP"); break; 350ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# endif 351ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case MPI_COMBINER_CONTIGUOUS: fprintf(f, "CONTIGUOUS"); break; 352ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case MPI_COMBINER_VECTOR: fprintf(f, "VECTOR"); break; 353ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown#if defined(MPI_COMBINER_HVECTOR_INTEGER) 354ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case MPI_COMBINER_HVECTOR_INTEGER: fprintf(f, "HVECTOR_INTEGER"); break; 355ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# endif 356ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case MPI_COMBINER_HVECTOR: fprintf(f, "HVECTOR"); break; 357ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case MPI_COMBINER_INDEXED: fprintf(f, "INDEXED"); break; 358ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown#if defined(MPI_COMBINER_HINDEXED_INTEGER) 359ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case MPI_COMBINER_HINDEXED_INTEGER: fprintf(f, "HINDEXED_INTEGER"); break; 360ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# endif 361ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case MPI_COMBINER_HINDEXED: fprintf(f, "HINDEXED"); break; 362ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown#if defined(MPI_COMBINER_INDEXED_BLOCK) 363ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case MPI_COMBINER_INDEXED_BLOCK: fprintf(f, "INDEXED_BLOCK"); break; 364ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# endif 365ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown#if defined(MPI_COMBINER_STRUCT_INTEGER) 366ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case MPI_COMBINER_STRUCT_INTEGER: fprintf(f, "STRUCT_INTEGER"); break; 367ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# endif 368ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case MPI_COMBINER_STRUCT: fprintf(f, "STRUCT"); break; 369ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown#if defined(MPI_COMBINER_SUBARRAY) 370ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case MPI_COMBINER_SUBARRAY: fprintf(f, "SUBARRAY"); break; 371ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# endif 372ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown#if defined(MPI_COMBINER_DARRAY) 373ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case MPI_COMBINER_DARRAY: fprintf(f, "DARRAY"); break; 374ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# endif 375ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown#if defined(MPI_COMBINER_F90_REAL) 376ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case MPI_COMBINER_F90_REAL: fprintf(f, "F90_REAL"); break; 377ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# endif 378ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown#if defined(MPI_COMBINER_F90_COMPLEX) 379ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case MPI_COMBINER_F90_COMPLEX: fprintf(f, "F90_COMPLEX"); break; 380ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# endif 381ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown#if defined(MPI_COMBINER_F90_INTEGER) 382ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case MPI_COMBINER_F90_INTEGER: fprintf(f, "F90_INTEGER"); break; 383ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# endif 384ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown#if defined(MPI_COMBINER_RESIZED) 385ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case MPI_COMBINER_RESIZED: fprintf(f, "RESIZED"); break; 386ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# endif 387ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown default: fprintf(f, "showCombiner:??"); break; 388ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 389ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 390ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 391ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 392ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* ------ Get useful bits of info ------ */ 393ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 394ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* Note, PMPI_Comm_rank/size are themselves wrapped. Should work 395ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown fine. */ 396ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 397ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownstatic __inline__ int comm_rank ( MPI_Comm comm ) 398ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown{ 399ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown int err, r; 400ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown err = PMPI_Comm_rank(comm, &r); 401ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return err ? 0/*arbitrary*/ : r; 402ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 403ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 404ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownstatic __inline__ int comm_size ( MPI_Comm comm ) 405ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown{ 406ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown int err, r; 407ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown err = PMPI_Comm_size(comm, &r); 408ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return err ? 0/*arbitrary*/ : r; 409ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 410ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 411ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownstatic __inline__ Bool count_from_Status( /*OUT*/int* recv_count, 412ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown MPI_Datatype datatype, 413ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown MPI_Status* status) 414ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown{ 415ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown int n; 416ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown int err = PMPI_Get_count(status, datatype, &n); 417ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (err == MPI_SUCCESS) { 418ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown *recv_count = n; 419ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return True; 420ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } else { 421ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return False; 422ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 423ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 424ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 425ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* It's critical that we can do equality on MPI_Requests. 426ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Unfortunately these are opaque objects to us (handles, in the 427ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown parlance of the MPI 1.1 spec). Fortunately Sec 2.4.1 ("Opaque 428ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Objects") specifies that "In C, [...] These [handles] should be 429ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown types that support assignment and equality operations." Hence the 430ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown following function should compile for any compliant definition of 431ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown MPI_Request. */ 432ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownstatic __inline__ 433ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownBool eq_MPI_Request ( MPI_Request r1, MPI_Request r2 ) 434ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown{ 435ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return r1 == r2; 436ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 437ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 438ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* Return True if status is MPI_STATUS_IGNORE or MPI_STATUSES_IGNORE. 439ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown On MPI-1.x platforms which don't have these symbols (and they would 440ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown only have them if they've been backported from 2.x) always return 441ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown False. */ 442ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownstatic __inline__ 443ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownBool isMSI ( MPI_Status* status ) 444ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown{ 445ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# if defined(HAVE_MPI_STATUS_IGNORE) 446ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return status == MPI_STATUSES_IGNORE || status == MPI_STATUS_IGNORE; 447ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# else 448ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return False; 449ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# endif 450ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 451ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 452ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* Get the 'extent' of a type. Note, as per the MPI spec this 453ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown includes whatever padding would be required when using 'ty' in an 454ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown array. */ 455ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownstatic long extentOfTy ( MPI_Datatype ty ) 456ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown{ 457ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown int r; 458ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown MPI_Aint n; 459ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown r = PMPI_Type_extent(ty, &n); 460ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown assert(r == MPI_SUCCESS); 461ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return (long)n; 462ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 463ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 464ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* Free up *ty, if it is safe to do so */ 465ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownstatic void maybeFreeTy ( MPI_Datatype* ty ) 466ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown{ 467ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown int r, n_ints, n_addrs, n_dtys, tycon; 468ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 469ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown r = PMPI_Type_get_envelope( *ty, &n_ints, &n_addrs, &n_dtys, &tycon ); 470ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown assert(r == MPI_SUCCESS); 471ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 472ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown /* can't free named types */ 473ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (tycon == MPI_COMBINER_NAMED) 474ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return; 475ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 476ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown /* some kinds of structs are predefined so we can't free them 477ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown either. */ 478ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (*ty == MPI_FLOAT_INT || *ty == MPI_DOUBLE_INT 479ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown || *ty == MPI_LONG_INT || *ty == MPI_2INT 480ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown || *ty == MPI_SHORT_INT || *ty == MPI_LONG_DOUBLE_INT) 481ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return; 482ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 483ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown /* Looks OK - free it. */ 484ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (0) { 485ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown /* show me what you're about to free .. */ 486ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown fprintf(stderr, "freeing combiner "); 487ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown showCombiner(stderr,tycon); 488ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown fprintf(stderr, " ty= "); 489ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown showTy(stderr,*ty); 490ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown fprintf(stderr,"\n"); 491ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 492ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown r = PMPI_Type_free(ty); 493ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown assert(r == MPI_SUCCESS); 494ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 495ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 496ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* How big is a "named" (base) type? Returns 0 if not known. Note. 497ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown There is a subtlety, which is that this is required to return the 498ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown exact size of one item of the type, NOT the size of it when padded 499ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown suitably to make an array of them. In particular that's why the 500ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown size of LONG_DOUBLE is computed by looking at the result of doing a 501ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown long double store, rather than just asking what is the sizeof(long 502ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown double). 503ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 504ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown For LONG_DOUBLE on x86-linux and amd64-linux my impression is that 505ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown the right answer is 10 even though sizeof(long double) says 12 and 506ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 16 respectively. On ppc32-linux it appears to be 16. 507ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 508ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Ref: MPI 1.1 doc p18 */ 509ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownstatic long sizeofOneNamedTy ( MPI_Datatype ty ) 510ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown{ 511ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (ty == MPI_CHAR) return sizeof(signed char); 512ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (ty == MPI_SHORT) return sizeof(signed short int); 513ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (ty == MPI_INT) return sizeof(signed int); 514ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (ty == MPI_LONG) return sizeof(signed long int); 515ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (ty == MPI_UNSIGNED_CHAR) return sizeof(unsigned char); 516ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (ty == MPI_UNSIGNED_SHORT) return sizeof(unsigned short int); 517ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (ty == MPI_UNSIGNED) return sizeof(unsigned int); 518ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (ty == MPI_UNSIGNED_LONG) return sizeof(unsigned long int); 519ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (ty == MPI_FLOAT) return sizeof(float); 520ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (ty == MPI_DOUBLE) return sizeof(double); 521ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (ty == MPI_BYTE) return 1; 522ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (ty == MPI_LONG_DOUBLE) return sizeof_long_double_image(); 523ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (ty == MPI_PACKED) return 1; 524ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (ty == MPI_LONG_LONG_INT) return sizeof(signed long long int); 525ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 526ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# if defined(MPI_REAL8) 527ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (ty == MPI_REAL8) return 8; /* MPI2 spec */; 528ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# endif 529ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# if defined(MPI_REAL4) 530ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (ty == MPI_REAL4) return 4; /* MPI2 spec */; 531ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# endif 532ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# if defined(MPI_REAL) 533ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (ty == MPI_REAL) return 4; /* MPI2 spec */; 534ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# endif 535ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# if defined(MPI_INTEGER8) 536ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (ty == MPI_INTEGER8) return 8; /* MPI2 spec */; 537ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# endif 538ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# if defined(MPI_INTEGER4) 539ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (ty == MPI_INTEGER4) return 4; /* MPI2 spec */; 540ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# endif 541ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# if defined(MPI_INTEGER) 542ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (ty == MPI_INTEGER) return 4; /* MPI2 spec */; 543ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# endif 544ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# if defined(MPI_DOUBLE_PRECISION) 545ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (ty == MPI_DOUBLE_PRECISION) return 8; /* MPI2 spec */; 546ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# endif 547ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 548ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown /* new in MPI2: */ 549ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# if defined(MPI_WCHAR) 550ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (ty == MPI_WCHAR) return 2; /* MPI2 spec */; 551ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# endif 552ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# if defined(MPI_SIGNED_CHAR) 553ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (ty == MPI_SIGNED_CHAR) return 1; /* MPI2 spec */; 554ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# endif 555ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# if defined(MPI_UNSIGNED_LONG_LONG) 556ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (ty == MPI_UNSIGNED_LONG_LONG) return 8; /* MPI2 spec */; 557ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# endif 558ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# if defined(MPI_COMPLEX) 559ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (ty == MPI_COMPLEX) return 2 * 4; /* MPI2 spec */ 560ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# endif 561ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# if defined(MPI_DOUBLE_COMPLEX) 562ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (ty == MPI_DOUBLE_COMPLEX) return 2 * 8; /* MPI2 spec */ 563ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# endif 564ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# if defined(MPI_LOGICAL) 565ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (ty == MPI_LOGICAL) return 4; /* MPI2 spec */ 566ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# endif 567ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# if defined(MPI_2INTEGER) 568ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (ty == MPI_2INTEGER) return 2 * 4; /* undocumented in MPI2 */ 569ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# endif 570ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# if defined(MPI_2COMPLEX) 571ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (ty == MPI_2COMPLEX) return 2 * 8; /* undocumented in MPI2 */ 572ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# endif 573ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# if defined(MPI_2DOUBLE_COMPLEX) 574ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown /* 32: this is how openmpi-1.2.2 behaves on x86-linux, but I have 575ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown really no idea if this is right. */ 576ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (ty == MPI_2DOUBLE_COMPLEX) return 32; /* undocumented in MPI2 */ 577ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# endif 578ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# if defined(MPI_2REAL) 579ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (ty == MPI_2REAL) return 2 * 4; /* undocumented in MPI2 */ 580ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# endif 581ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# if defined(MPI_2DOUBLE_PRECISION) 582ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (ty == MPI_2DOUBLE_PRECISION) return 2 * 8; /* undocumented in MPI2 */ 583ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# endif 584ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# if defined(MPI_CHARACTER) 585ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (ty == MPI_CHARACTER) return 1; /* MPI2 spec */ 586ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown# endif 587ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 588ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown /* Note: the following are named structs, not named basic types, 589ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown and so are not handled here: 590ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown FLOAT_INT DOUBLE_INT LONG_INT 2INT SHORT_INT LONG_DOUBLE_INT 591ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown My guess is they are probably for doing max-w-index style 592ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown reductions, the INT carrying the index of the max/min and the 593ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown other type its actual value. 594ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown */ 595ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return 0; 596ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 597ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 598ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 599ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* Find the size of long double image (not 'sizeof(long double)'). 600ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown See comments in sizeofOneNamedTy. 601ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown*/ 602ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownstatic long sizeof_long_double_image ( void ) 603ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown{ 604ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown long i; 605ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown unsigned char* p; 606ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown static long cached_result = 0; 607ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 608ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown /* Hopefully we have it already. */ 609ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (cached_result != 0) { 610ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown assert(cached_result == 10 || cached_result == 16 || cached_result == 8); 611ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return cached_result; 612ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 613ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 614ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown /* No? Then we'll have to compute it. This isn't thread-safe but 615ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown it doesn't really matter since all races to compute it should 616ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown produce the same answer. */ 617ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown p = malloc(64); 618ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown assert(p); 619ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown for (i = 0; i < 64; i++) 620ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown p[i] = 0x55; 621ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 622ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown /* Write a value which isn't known at compile time and therefore 623ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown must come out of a register. If we just store a constant here, 624ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown some compilers write more data than a store from a machine 625ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown register would. Therefore we have to force a store from a 626ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown machine register by storing a value which isn't known at compile 627ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown time. Since getpid() will return a value < 1 million, turn it 628ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown into a zero by dividing by 1e+30. */ 629ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown *(long double*)(&p[16]) = (long double)(1.0e-30 * (double)getpid()); 630ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 631ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown for (i = 0; i < 16; i++) { 632ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown assert(p[i] == 0x55); 633ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown assert(p[i+48] == 0x55); 634ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 635ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown for (i = 16; i <= 48; i++) { 636ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (p[i] == 0x55) 637ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown break; 638ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 639ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 640ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown assert(i < 48); 641ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown assert(i > 16); 642ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown free(p); 643ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown cached_result = i - 16; 644ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 645ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (0) 646ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown printf("sizeof_long_double_image: computed %d\n", (int)cached_result); 647ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 648ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown assert(cached_result == 10 || cached_result == 16 || cached_result == 8); 649ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return cached_result; 650ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 651ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 652ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 653ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*------------------------------------------------------------*/ 654ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*--- Unpicking datatypes ---*/ 655ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*------------------------------------------------------------*/ 656ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 657ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownstatic __inline__ 658ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownvoid walk_type_array ( void(*f)(void*,long), char* base, 659ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown MPI_Datatype ty, long count ); 660ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 661ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 662ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* Walk over all fragments of the object of type 'ty' with base 663ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown address 'base', and apply 'f' to the start/length of each 664ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown contiguous fragment. */ 665ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownstatic 666ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownvoid walk_type ( void(*f)(void*,long), char* base, MPI_Datatype ty ) 667ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown{ 668ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown int r, n_ints, n_addrs, n_dtys, tycon; 669ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown long ex, i; 670ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown int* ints = NULL; 671ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown MPI_Aint* addrs = NULL; 672ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown MPI_Datatype* dtys = NULL; 673ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 674ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown /* Stuff for limiting how much complaining text it spews out */ 675ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown static int complaints = 3; 676ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown static int last_complained_about_tycon = -987654321; /* presumably bogus */ 677ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 678ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (0) 679ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown printf("walk_type %p\n", (void*)(unsigned long)ty); 680ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 681ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown r = PMPI_Type_get_envelope( ty, &n_ints, &n_addrs, &n_dtys, &tycon ); 682ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown assert(r == MPI_SUCCESS); 683ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 684ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown /* Handle the base cases fast(er/ish). */ 685ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (tycon == MPI_COMBINER_NAMED) { 686ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown long sz = sizeofOneNamedTy(ty); 687ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (sz > 0) { 688ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown f(base, sz); 689ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return; 690ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 691ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown /* Hmm. Perhaps it's a named struct? Unfortunately we can't 692ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown take them to bits so we have to do a really ugly hack, which 693ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown makes assumptions about how the MPI implementation has laid 694ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown out these types. At least Open MPI 1.0.1 appears to put 695ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown the 'val' field first. MPICH2 agrees. 696ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown */ 697ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (ty == MPI_2INT) { 698ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown typedef struct { int val; int loc; } Ty; 699ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown f(base + offsetof(Ty,val), sizeof(int)); 700ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown f(base + offsetof(Ty,loc), sizeof(int)); 701ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return; 702ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 703ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (ty == MPI_LONG_INT) { 704ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown typedef struct { long val; int loc; } Ty; 705ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown f(base + offsetof(Ty,val), sizeof(long)); 706ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown f(base + offsetof(Ty,loc), sizeof(int)); 707ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return; 708ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 709ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (ty == MPI_DOUBLE_INT) { 710ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown typedef struct { double val; int loc; } Ty; 711ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown f(base + offsetof(Ty,val), sizeof(double)); 712ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown f(base + offsetof(Ty,loc), sizeof(int)); 713ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return; 714ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 715ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (ty == MPI_SHORT_INT) { 716ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown typedef struct { short val; int loc; } Ty; 717ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown f(base + offsetof(Ty,val), sizeof(short)); 718ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown f(base + offsetof(Ty,loc), sizeof(int)); 719ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return; 720ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 721ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (ty == MPI_FLOAT_INT) { 722ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown typedef struct { float val; int loc; } Ty; 723ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown f(base + offsetof(Ty,val), sizeof(float)); 724ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown f(base + offsetof(Ty,loc), sizeof(int)); 725ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return; 726ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 727ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (ty == MPI_LONG_DOUBLE_INT) { 728ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown typedef struct { long double val; int loc; } Ty; 729ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown f(base + offsetof(Ty,val), sizeof_long_double_image()); 730ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown f(base + offsetof(Ty,loc), sizeof(int)); 731ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return; 732ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 733ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (ty == MPI_LB || ty == MPI_UB) 734ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return; /* have zero size, so nothing needs to be done */ 735ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown goto unhandled; 736ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown /*NOTREACHED*/ 737ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 738ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 739ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (0) { 740ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown ex = extentOfTy(ty); 741ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown printf("tycon 0x%llx %d %d %d (ext %d)\n", 742ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown (unsigned long long int)tycon, 743ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown n_ints, n_addrs, n_dtys, (int)ex ); 744ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 745ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 746ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown /* Now safe to do MPI_Type_get_contents */ 747ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown assert(n_ints >= 0); 748ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown assert(n_addrs >= 0); 749ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown assert(n_dtys >= 0); 750ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 751ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (n_ints > 0) { 752ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown ints = malloc(n_ints * sizeof(int)); 753ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown assert(ints); 754ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 755ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (n_addrs > 0) { 756ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown addrs = malloc(n_addrs * sizeof(MPI_Aint)); 757ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown assert(addrs); 758ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 759ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (n_dtys > 0) { 760ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown dtys = malloc(n_dtys * sizeof(MPI_Datatype)); 761ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown assert(dtys); 762ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 763ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 764ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown r = PMPI_Type_get_contents( ty, n_ints, n_addrs, n_dtys, 765ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown ints, addrs, dtys ); 766ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown assert(r == MPI_SUCCESS); 767ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 768ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown switch (tycon) { 769ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 770ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case MPI_COMBINER_CONTIGUOUS: 771ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown assert(n_ints == 1 && n_addrs == 0 && n_dtys == 1); 772ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown walk_type_array( f, base, dtys[0], ints[0] ); 773ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown maybeFreeTy( &dtys[0] ); 774ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown break; 775ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 776ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case MPI_COMBINER_VECTOR: 777ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown assert(n_ints == 3 && n_addrs == 0 && n_dtys == 1); 778ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown ex = extentOfTy(dtys[0]); 779ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (0) 780ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown printf("vector count %d x (bl %d stride %d)\n", 781ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown (int)ints[0], (int)ints[1], (int)ints[2]); 782ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown for (i = 0; i < ints[0]; i++) { 783ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown walk_type_array( f, base + i * ints[2]/*stride*/ * ex, 784ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown dtys[0], ints[1]/*blocklength*/ ); 785ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 786ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown maybeFreeTy( &dtys[0] ); 787ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown break; 788ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 789ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case MPI_COMBINER_HVECTOR: 790ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown assert(n_ints == 2 && n_addrs == 1 && n_dtys == 1); 791ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown ex = extentOfTy(dtys[0]); 792ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (0) 793ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown printf("hvector count %d x (bl %d hstride %d)\n", 794ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown (int)ints[0], (int)ints[1], (int)addrs[0]); 795ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown for (i = 0; i < ints[0]; i++) { 796ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown walk_type_array( f, base + i * addrs[0]/*hstride*/, 797ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown dtys[0], ints[1]/*blocklength*/ ); 798ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 799ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown maybeFreeTy( &dtys[0] ); 800ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown break; 801ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 802ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case MPI_COMBINER_INDEXED: 803ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown assert(n_addrs == 0 && n_dtys == 1); 804ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown assert(n_ints > 0); 805ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown assert(n_ints == 2 * ints[0] + 1); 806ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown ex = extentOfTy(dtys[0]); 807ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown for (i = 0; i < ints[0]; i++) { 808ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (0) 809ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown printf("indexed (elem %d) off %d copies %d\n", 810ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown (int)i, ints[i+1+ints[0]], ints[i+1] ); 811ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown walk_type_array( f, base + ex * ints[i+1+ints[0]], 812ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown dtys[0], ints[i+1] ); 813ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 814ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown maybeFreeTy( &dtys[0] ); 815ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown break; 816ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 817ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case MPI_COMBINER_HINDEXED: 818ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown assert(n_ints > 0); 819ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown assert(n_ints == ints[0] + 1); 820ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown assert(n_addrs == ints[0] && n_dtys == 1); 821ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown ex = extentOfTy(dtys[0]); 822ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown for (i = 0; i < ints[0]; i++) { 823ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (0) 824ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown printf("hindexed (elem %d) hoff %d copies %d\n", 825ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown (int)i, (int)addrs[i], ints[i+1] ); 826ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown walk_type_array( f, base + addrs[i], 827ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown dtys[0], ints[i+1] ); 828ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 829ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown maybeFreeTy( &dtys[0] ); 830ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown break; 831ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 832ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown case MPI_COMBINER_STRUCT: 833ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown assert(n_addrs == n_ints-1); 834ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown assert(n_dtys == n_ints-1); 835ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown assert(n_ints > 0); 836ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown assert(n_ints == ints[0] + 1); 837ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown for (i = 0; i < ints[0]; i++) { 838ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (0) 839ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown printf("struct (elem %d limit %d) hoff %d copies %d\n", 840ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown (int)i, (int)ints[0], (int)addrs[i], (int)ints[i+1]); 841ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown walk_type_array( f, base + addrs[i], dtys[i], (long)ints[i+1] ); 842ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown maybeFreeTy( &dtys[i] ); 843ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 844ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown break; 845ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 846ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown default: 847ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown goto unhandled; 848ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 849ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 850ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 851ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown /* normal exit */ 852ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (ints) free(ints); 853ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (addrs) free(addrs); 854ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (dtys) free(dtys); 855ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return; 856ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 857ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown unhandled: 858ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown /* Complain, but limit the amount of complaining that can happen to 859ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown the first 3 different unhandled tycons that show up, so as to 860ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown avoid swamping users with thousands of duplicate messages. */ 861ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (complaints > 0 && tycon != last_complained_about_tycon) { 862ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown complaints--; 863ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown last_complained_about_tycon = tycon; 864ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (tycon == MPI_COMBINER_NAMED) { 865ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown fprintf(stderr, "%s %5d: walk_type: unhandled base type 0x%lx ", 866ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown preamble, my_pid, (long)ty); 867ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown showTy(stderr, ty); 868ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown fprintf(stderr, "\n"); 869ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } else { 870ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown fprintf(stderr, "%s %5d: walk_type: unhandled combiner 0x%lx\n", 871ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown preamble, my_pid, (long)tycon); 872ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 873ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 874ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (ints) free(ints); 875ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (addrs) free(addrs); 876ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (dtys) free(dtys); 877ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (opt_missing >= 2) 878ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown barf("walk_type: unhandled combiner, strict checking selected"); 879ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 880ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 881ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 882ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* Same as walk_type but apply 'f' to every element in an array of 883ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 'count' items starting at 'base'. The only purpose of pushing this 884ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown into a different routine is so it can attempt to optimise the case 885ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown where the array elements are contiguous and packed together without 886ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown holes. */ 887ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownstatic __inline__ 888ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownvoid walk_type_array ( void(*f)(void*,long), char* base, 889ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown MPI_Datatype elemTy, long count ) 890ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown{ 891ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown long i, ex; 892ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 893ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown assert(sizeof(unsigned long) == sizeof(char*)); 894ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 895ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown /* First see if we can do this the fast way. */ 896ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown ex = sizeofOneNamedTy(elemTy); 897ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 898ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if ( /* ty is a primitive type with power-of-2 size */ 899ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown (ex == 8 || ex == 4 || ex == 2 || ex == 1) 900ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown && /* base is suitably aligned for ty */ 901ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown ( ((unsigned long)base) & (ex-1)) == 0) { 902ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 903ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown /* We're sure it's contiguous, so just paint/check it in one 904ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown go. */ 905ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (0) printf("walk_type_array fast %ld of size %ld\n", count, ex ); 906ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown f ( base, count * ex ); 907ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 908ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } else { 909ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 910ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown /* Bad news. We have to futz with each element individually. 911ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown This could be very expensive. 912ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 913ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Note: subtle. If ty is LONG_DOUBLE then the extent will be 914ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 12, so the following loop will jump along in steps of 12, but 915ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown the size painted by walk_type will be 10 since it uses 916ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown sizeofOneNamedTy to establish the size of base types. Which 917ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown is what we need to happen. */ 918ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown ex = extentOfTy(elemTy); 919ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (0) printf("walk_type_array SLOW %ld of size %ld\n", count, ex ); 920ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown for (i = 0; i < count; i++) 921ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown walk_type( f, base + i * ex, elemTy ); 922ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 923ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 924ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 925ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 926ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 927ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* Hook so it's visible from outside (can be handy to dlopen/dlsym 928ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown it) */ 929ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownvoid mpiwrap_walk_type_EXTERNALLY_VISIBLE 930ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown ( void(*f)(void*,long), char* base, MPI_Datatype ty ) 931ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown{ 932ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown walk_type(f, base, ty); 933ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 934ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 935ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 936ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*------------------------------------------------------------*/ 937ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*--- Address-range helpers ---*/ 938ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*------------------------------------------------------------*/ 939ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 940ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* ---------------- 941ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Do corresponding checks on memory areas defined using a 942ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown straightforward (start, length) description. 943ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown ---------------- 944ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown*/ 945ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 946ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownstatic __inline__ 947ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownvoid check_mem_is_defined_untyped ( void* buffer, long nbytes ) 948ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown{ 949ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (nbytes > 0) { 950ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown VALGRIND_CHECK_MEM_IS_DEFINED(buffer, nbytes); 951ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 952ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 953ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 954ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownstatic __inline__ 955ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownvoid check_mem_is_addressable_untyped ( void* buffer, long nbytes ) 956ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown{ 957ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (nbytes > 0) { 958ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown VALGRIND_CHECK_MEM_IS_ADDRESSABLE(buffer, nbytes); 959ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 960ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 961ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 962ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownstatic __inline__ 963ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownvoid make_mem_defined_if_addressable_untyped ( void* buffer, long nbytes ) 964ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown{ 965ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (nbytes > 0) { 966ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown VALGRIND_MAKE_MEM_DEFINED_IF_ADDRESSABLE(buffer, nbytes); 967ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 968ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 969ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 970ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownstatic __inline__ 971ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownvoid make_mem_defined_if_addressable_if_success_untyped ( int err, 972ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown void* buffer, long nbytes ) 973ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown{ 974ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (err == MPI_SUCCESS && nbytes > 0) { 975ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown VALGRIND_MAKE_MEM_DEFINED_IF_ADDRESSABLE(buffer, nbytes); 976ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 977ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 978ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 979ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 980ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* ---------------- 981ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Do checks on memory areas defined using the MPI (buffer, count, 982ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown type) convention. 983ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown ---------------- 984ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown*/ 985ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 986ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* Check that the specified area is both addressible and contains 987ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown initialised data, and cause V to complain if not. */ 988ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 989ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownstatic __inline__ 990ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownvoid check_mem_is_defined ( char* buffer, long count, MPI_Datatype datatype ) 991ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown{ 992ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown walk_type_array( check_mem_is_defined_untyped, buffer, datatype, count ); 993ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 994ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 995ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 996ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* Check that the specified area is addressible, and cause V to 997ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown complain if not. Doesn't matter whether the data there is 998ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown initialised or not. */ 999ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1000ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownstatic __inline__ 1001ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownvoid check_mem_is_addressable ( void *buffer, long count, MPI_Datatype datatype ) 1002ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown{ 1003ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown walk_type_array( check_mem_is_addressable_untyped, buffer, datatype, count ); 1004ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 1005ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1006ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1007ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* Set the specified area to 'defined for each byte which is 1008ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown addressible' state. */ 1009ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1010ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownstatic __inline__ 1011ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownvoid make_mem_defined_if_addressable ( void *buffer, int count, MPI_Datatype datatype ) 1012ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown{ 1013ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown walk_type_array( make_mem_defined_if_addressable_untyped, 1014ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown buffer, datatype, count ); 1015ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 1016ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1017ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownstatic __inline__ 1018ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownvoid 1019ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownmake_mem_defined_if_addressable_if_success ( int err, void *buffer, int count, 1020ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown MPI_Datatype datatype ) 1021ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown{ 1022ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (err == MPI_SUCCESS) 1023ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown make_mem_defined_if_addressable(buffer, count, datatype); 1024ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 1025ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1026ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1027ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*------------------------------------------------------------*/ 1028ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*--- ---*/ 1029ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*--- The wrappers proper. They are listed in the order ---*/ 1030ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*--- in which they appear in "MPI: A Message-Passing ---*/ 1031ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*--- Interface Standard, MPIF, Nov 15 2003" (the MPI 1.1 ---*/ 1032ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*--- spec. All unimplemented wrappers are listed at the ---*/ 1033ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*--- end of the file. The list of function names is ---*/ 1034ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*--- taken from the headers of Open MPI svn r9191. ---*/ 1035ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*--- Hopefully it is a complete list of all the MPI 2 ---*/ 1036ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*--- functions. ---*/ 1037ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*--- ---*/ 1038ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*------------------------------------------------------------*/ 1039ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1040ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* Handy abbreviation */ 1041ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown#define WRAPPER_FOR(name) I_WRAP_FNNAME_U(name) 1042ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1043ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* Generates (conceptually) a wrapper which does nothing. In 1044ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown fact just generate no wrapper at all. */ 1045ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown#define HAS_NO_WRAPPER(basename) /* */ 1046ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1047ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1048ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*------------------------------------------------------------*/ 1049ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*--- ---*/ 1050ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*--- Sec 3.2, Blocking Send and Receive Operations ---*/ 1051ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*--- ---*/ 1052ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*------------------------------------------------------------*/ 1053ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1054ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* --- {,B,S,R}Send --- */ 1055ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* pre: rd: (buf,count,datatype) */ 1056ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownstatic 1057ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownint generic_Send(void *buf, int count, MPI_Datatype datatype, 1058ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown int dest, int tag, MPI_Comm comm) 1059ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown{ 1060ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown OrigFn fn; 1061ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown int err; 1062ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown VALGRIND_GET_ORIG_FN(fn); 1063ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown before("{,B,S,R}Send"); 1064ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown check_mem_is_defined(buf, count, datatype); 1065b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_DISABLE_ERROR_REPORTING; 1066ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown CALL_FN_W_6W(err, fn, buf,count,datatype,dest,tag,comm); 1067b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_ENABLE_ERROR_REPORTING; 1068ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown after("{,B,S,R}Send", err); 1069ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return err; 1070ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 1071ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownint WRAPPER_FOR(PMPI_Send)(void *buf, int count, MPI_Datatype datatype, 1072ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown int dest, int tag, MPI_Comm comm) { 1073ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return generic_Send(buf,count,datatype, dest,tag,comm); 1074ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 1075ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownint WRAPPER_FOR(PMPI_Bsend)(void *buf, int count, MPI_Datatype datatype, 1076ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown int dest, int tag, MPI_Comm comm) { 1077ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return generic_Send(buf,count,datatype, dest,tag,comm); 1078ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 1079ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownint WRAPPER_FOR(PMPI_Ssend)(void *buf, int count, MPI_Datatype datatype, 1080ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown int dest, int tag, MPI_Comm comm) { 1081ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return generic_Send(buf,count,datatype, dest,tag,comm); 1082ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 1083ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownint WRAPPER_FOR(PMPI_Rsend)(void *buf, int count, MPI_Datatype datatype, 1084ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown int dest, int tag, MPI_Comm comm) { 1085ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return generic_Send(buf,count,datatype, dest,tag,comm); 1086ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 1087ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1088ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* --- Recv --- */ 1089ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* pre: must be writable: (buf,count,datatype) 1090ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown must be writable: status 1091ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown post: make readable: (buf,recv_count,datatype) 1092ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown where recv_count is determined from *status 1093ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown*/ 1094ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownint WRAPPER_FOR(PMPI_Recv)(void *buf, int count, MPI_Datatype datatype, 1095ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown int source, int tag, 1096ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown MPI_Comm comm, MPI_Status *status) 1097ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown{ 1098ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown OrigFn fn; 1099ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown int err, recv_count = 0; 1100ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown MPI_Status fake_status; 1101ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown VALGRIND_GET_ORIG_FN(fn); 1102ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown before("Recv"); 1103ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (isMSI(status)) 1104ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown status = &fake_status; 1105ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown check_mem_is_addressable(buf, count, datatype); 1106ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown check_mem_is_addressable_untyped(status, sizeof(*status)); 1107b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_DISABLE_ERROR_REPORTING; 1108ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown CALL_FN_W_7W(err, fn, buf,count,datatype,source,tag,comm,status); 1109b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_ENABLE_ERROR_REPORTING; 1110ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (err == MPI_SUCCESS && count_from_Status(&recv_count,datatype,status)) { 1111ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown make_mem_defined_if_addressable(buf, recv_count, datatype); 1112ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 1113ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown after("Recv", err); 1114ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return err; 1115ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 1116ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1117ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* --- Get_count --- */ 1118ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* pre: must be readable: *status 1119ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown post: make defined: *count -- don't bother, libmpi will surely do this 1120ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown*/ 1121ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownint WRAPPER_FOR(PMPI_Get_count)(MPI_Status* status, 1122ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown MPI_Datatype ty, int* count ) 1123ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown{ 1124ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown OrigFn fn; 1125ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown int err; 1126ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown VALGRIND_GET_ORIG_FN(fn); 1127ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown before("Get_count"); 1128ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown check_mem_is_defined_untyped(status, sizeof(*status)); 1129b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_DISABLE_ERROR_REPORTING; 1130ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown CALL_FN_W_WWW(err, fn, status,ty,count); 1131b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_ENABLE_ERROR_REPORTING; 1132ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown after("Get_count", err); 1133ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return err; 1134ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 1135ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1136ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1137ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*------------------------------------------------------------*/ 1138ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*--- ---*/ 1139ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*--- Sec 3.7, Nonblocking communication ---*/ 1140ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*--- ---*/ 1141ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*------------------------------------------------------------*/ 1142ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1143ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* Maintain a table that makes it possible for the wrappers to 1144ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown complete MPI_Irecv successfully. 1145ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1146ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown The issue is that MPI_Irecv states the recv buffer and returns 1147ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown immediately, giving a handle (MPI_Request) for the transaction. 1148ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Later the user will have to poll for completion with MPI_Wait etc, 1149ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown and at that point these wrappers have to paint the recv buffer. 1150ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown But the recv buffer details are not presented to MPI_Wait - only 1151ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown the handle is. We therefore have to use a shadow table 1152ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown (sReqs{,_size,_used,_lock}) which associates uncompleted 1153ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown MPI_Requests with the corresponding buffer address/count/type. 1154ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1155ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Only read requests are placed in the table, since there is no need 1156ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown to do any buffer painting following completion of an Isend - all 1157ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown the checks for that are done at the time Isend is called. 1158ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1159ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Care has to be take to remove completed requests from the table. 1160ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1161ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Access to the table is guarded by sReqs_lock so as to make it 1162ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown thread-safe. 1163ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown*/ 1164ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1165ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Browntypedef 1166ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown struct { 1167ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Bool inUse; 1168ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown MPI_Request key; 1169ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown void* buf; 1170ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown int count; 1171ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown MPI_Datatype datatype; 1172ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 1173ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown ShadowRequest; 1174ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1175ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownstatic ShadowRequest* sReqs = NULL; 1176ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownstatic int sReqs_size = 0; 1177ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownstatic int sReqs_used = 0; 1178ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownstatic pthread_mutex_t sReqs_lock = PTHREAD_MUTEX_INITIALIZER; 1179ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1180ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown#define LOCK_SREQS \ 1181ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown do { int pr = pthread_mutex_lock(&sReqs_lock); \ 1182ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown assert(pr == 0); \ 1183ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } while (0) 1184ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1185ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown#define UNLOCK_SREQS \ 1186ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown do { int pr = pthread_mutex_unlock(&sReqs_lock); \ 1187ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown assert(pr == 0); \ 1188ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } while (0) 1189ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1190ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1191ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* Ensure the sReqs expandable array has at least one free slot, by 1192ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown copying it into a larger one if necessary. NOTE: sReqs_lock is 1193ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown held throughout this procedure.*/ 1194ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownstatic void ensure_sReq_space ( void ) 1195ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown{ 1196ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown int i; 1197ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown ShadowRequest* sReqs2; 1198ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (sReqs_used == sReqs_size) { 1199ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown sReqs_size = sReqs_size==0 ? 2 : 2*sReqs_size; 1200ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown sReqs2 = malloc( sReqs_size * sizeof(ShadowRequest) ); 1201ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (sReqs2 == NULL) { 1202ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown UNLOCK_SREQS; 1203ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown barf("add_shadow_Request: malloc failed.\n"); 1204ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 1205ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown for (i = 0; i < sReqs_used; i++) 1206ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown sReqs2[i] = sReqs[i]; 1207ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (sReqs) 1208ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown free(sReqs); 1209ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown sReqs = sReqs2; 1210ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 1211ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown assert(sReqs_used < sReqs_size); 1212ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 1213ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1214ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1215ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* Find shadow info for 'request', or NULL if none. */ 1216ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1217ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownstatic 1218ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownShadowRequest* find_shadow_Request ( MPI_Request request ) 1219ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown{ 1220ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown ShadowRequest* ret = NULL; 1221ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown int i; 1222ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown LOCK_SREQS; 1223ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown for (i = 0; i < sReqs_used; i++) { 1224ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (sReqs[i].inUse && eq_MPI_Request(sReqs[i].key,request)) { 1225ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown ret = &sReqs[i]; 1226ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown break; 1227ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 1228ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 1229ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown UNLOCK_SREQS; 1230ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return ret; 1231ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 1232ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1233ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1234ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* Delete shadow info for 'request', if any. */ 1235ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1236ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownstatic void delete_shadow_Request ( MPI_Request request ) 1237ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown{ 1238ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown int i; 1239ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown LOCK_SREQS; 1240ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown for (i = 0; i < sReqs_used; i++) { 1241ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (sReqs[i].inUse && eq_MPI_Request(sReqs[i].key,request)) { 1242ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown sReqs[i].inUse = False; 1243ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown break; 1244ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 1245ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 1246ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown UNLOCK_SREQS; 1247ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 1248ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1249ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1250ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* Add a shadow for 'request', overwriting any old binding for it. */ 1251ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1252ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownstatic 1253ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownvoid add_shadow_Request( MPI_Request request, 1254ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown void* buf, int count, 1255ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown MPI_Datatype datatype ) 1256ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown{ 1257ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown int i, ix = -1; 1258ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown LOCK_SREQS; 1259ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown assert(sReqs_used >= 0); 1260ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown assert(sReqs_size >= 0); 1261ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown assert(sReqs_used <= sReqs_size); 1262ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (sReqs == NULL) assert(sReqs_size == 0); 1263ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1264ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown /* First of all see if we already have a binding for this key; if 1265ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown so just replace it, and have done. */ 1266ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown for (i = 0; i < sReqs_used; i++) { 1267ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (sReqs[i].inUse && eq_MPI_Request(sReqs[i].key,request)) { 1268ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown ix = i; 1269ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown break; 1270ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 1271ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 1272ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1273ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (ix < 0) { 1274ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown /* Ok, we don't have it, so will have to add it. First search 1275ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown to see if there is an existing empty slot. */ 1276ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown for (i = 0; i < sReqs_used; i++) { 1277ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (!sReqs[i].inUse) { 1278ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown ix = i; 1279ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown break; 1280ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 1281ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 1282ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 1283ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1284ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown /* No empty slots. Allocate a new one. */ 1285ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (ix < 0) { 1286ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown ensure_sReq_space(); 1287ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown assert(sReqs_used < sReqs_size); 1288ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown ix = sReqs_used; 1289ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown sReqs_used++; 1290ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 1291ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1292ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown assert(ix >= 0 && ix < sReqs_used); 1293ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown assert(sReqs_used <= sReqs_size); 1294ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1295ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown sReqs[ix].inUse = True; 1296ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown sReqs[ix].key = request; 1297ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown sReqs[ix].buf = buf; 1298ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown sReqs[ix].count = count; 1299ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown sReqs[ix].datatype = datatype; 1300ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1301ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown UNLOCK_SREQS; 1302ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (opt_verbosity > 1) 1303ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown fprintf(stderr, "%s %5d: sReq+ 0x%lx -> b/c/d %p/%d/0x%lx [slot %d]\n", 1304ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown preamble, my_pid, (unsigned long)request, 1305ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown buf, count, (long)datatype, ix); 1306ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 1307ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1308ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownstatic 1309ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownMPI_Request* clone_Request_array ( int count, MPI_Request* orig ) 1310ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown{ 1311ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown MPI_Request* copy; 1312ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown int i; 1313ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown LOCK_SREQS; 1314ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (count < 0) 1315ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown count = 0; /* Hmm. Call Mulder and Scully. */ 1316ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown copy = malloc( count * sizeof(MPI_Request) ); 1317ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (copy == NULL && count > 0) { 1318ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown UNLOCK_SREQS; 1319ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown barf("clone_Request_array: malloc failed"); 1320ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 1321ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown for (i = 0; i < count; i++) 1322ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown copy[i] = orig[i]; 1323ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown UNLOCK_SREQS; 1324ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return copy; 1325ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 1326ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1327ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown#undef LOCK_SREQS 1328ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown#undef UNLOCK_SREQS 1329ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1330ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1331ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownstatic void maybe_complete ( Bool error_in_status, 1332ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown MPI_Request request_before, 1333ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown MPI_Request request_after, 1334ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown MPI_Status* status ) 1335ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown{ 1336ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown int recv_count = 0; 1337ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown ShadowRequest* shadow; 1338ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown /* How do we know if this is an Irecv request that has now 1339ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown finished successfully? 1340ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1341ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown request_before isn't MPI_REQUEST_NULL 1342ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown and request_before is found in the shadow table 1343ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown and request_after *is* MPI_REQUEST_NULL 1344ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown and (if error_in_status then status.MPI_ERROR is MPI_SUCCESS) 1345ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1346ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown (when error_in_status == False, then we expect not to get 1347ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown called at all if there was an error.) 1348ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown */ 1349ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (request_before != MPI_REQUEST_NULL 1350ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown && request_after == MPI_REQUEST_NULL 1351ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown && (error_in_status ? status->MPI_ERROR == MPI_SUCCESS : True) 1352ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown && ( (shadow=find_shadow_Request(request_before)) != NULL) ) { 1353ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown /* The Irecv detailed in 'shadow' completed. Paint the result 1354ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown buffer, and delete the entry. */ 1355ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (count_from_Status(&recv_count, shadow->datatype, status)) { 1356ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown make_mem_defined_if_addressable(shadow->buf, recv_count, shadow->datatype); 1357ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (opt_verbosity > 1) 1358ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown fprintf(stderr, "%s %5d: sReq- %p (completed)\n", 1359ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown preamble, my_pid, request_before); 1360ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 1361ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown delete_shadow_Request(request_before); 1362ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 1363ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 1364ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1365ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1366ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* --- Isend --- */ 1367ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* rd: (buf,count,datatype) */ 1368ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* wr: *request */ 1369ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownstatic __inline__ 1370ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownint generic_Isend(void *buf, int count, MPI_Datatype datatype, 1371ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown int dest, int tag, MPI_Comm comm, 1372ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown MPI_Request* request) 1373ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown{ 1374ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown OrigFn fn; 1375ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown int err; 1376ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown VALGRIND_GET_ORIG_FN(fn); 1377ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown before("{,B,S,R}Isend"); 1378ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown check_mem_is_defined(buf, count, datatype); 1379ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown check_mem_is_addressable_untyped(request, sizeof(*request)); 1380b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_DISABLE_ERROR_REPORTING; 1381ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown CALL_FN_W_7W(err, fn, buf,count,datatype,dest,tag,comm,request); 1382b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_ENABLE_ERROR_REPORTING; 1383ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown make_mem_defined_if_addressable_if_success_untyped(err, request, sizeof(*request)); 1384ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown after("{,B,S,R}Isend", err); 1385ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return err; 1386ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 1387ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownint WRAPPER_FOR(PMPI_Isend)(void *buf, int count, MPI_Datatype datatype, 1388ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown int dest, int tag, MPI_Comm comm, 1389ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown MPI_Request* request) { 1390ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return generic_Isend(buf,count,datatype, dest,tag,comm, request); 1391ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 1392ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownint WRAPPER_FOR(PMPI_Ibsend)(void *buf, int count, MPI_Datatype datatype, 1393ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown int dest, int tag, MPI_Comm comm, 1394ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown MPI_Request* request) { 1395ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return generic_Isend(buf,count,datatype, dest,tag,comm, request); 1396ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 1397ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownint WRAPPER_FOR(PMPI_Issend)(void *buf, int count, MPI_Datatype datatype, 1398ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown int dest, int tag, MPI_Comm comm, 1399ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown MPI_Request* request) { 1400ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return generic_Isend(buf,count,datatype, dest,tag,comm, request); 1401ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 1402ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownint WRAPPER_FOR(PMPI_Irsend)(void *buf, int count, MPI_Datatype datatype, 1403ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown int dest, int tag, MPI_Comm comm, 1404ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown MPI_Request* request) { 1405ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return generic_Isend(buf,count,datatype, dest,tag,comm, request); 1406ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 1407ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1408ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1409ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* --- Irecv --- */ 1410ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* pre: must be writable: (buf,count,datatype), *request 1411ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown post: make readable *request 1412ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown add a request->(buf,count,ty) binding to the 1413ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown shadow request table. 1414ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown*/ 1415ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownint WRAPPER_FOR(PMPI_Irecv)( void* buf, int count, MPI_Datatype datatype, 1416ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown int source, int tag, MPI_Comm comm, 1417ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown MPI_Request* request ) 1418ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown{ 1419ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown OrigFn fn; 1420ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown int err; 1421ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown VALGRIND_GET_ORIG_FN(fn); 1422ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown before("Irecv"); 1423ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown check_mem_is_addressable(buf, count, datatype); 1424ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown check_mem_is_addressable_untyped(request, sizeof(*request)); 1425b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_DISABLE_ERROR_REPORTING; 1426ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown CALL_FN_W_7W(err, fn, buf,count,datatype,source,tag,comm,request); 1427b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_ENABLE_ERROR_REPORTING; 1428ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (err == MPI_SUCCESS) { 1429ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown make_mem_defined_if_addressable_untyped(request, sizeof(*request)); 1430ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown add_shadow_Request( *request, buf,count,datatype ); 1431ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 1432ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown after("Irecv", err); 1433ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return err; 1434ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 1435ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1436ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* --- Wait --- */ 1437ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* The MPI1 spec (imprecisely) defines 3 request states: 1438ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown - "null" if the request is MPI_REQUEST_NULL 1439ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown - "inactive" if not "null" and not associated with ongoing comms 1440ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown - "active" if not "null" and is associated with ongoing comms 1441ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown*/ 1442ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownint WRAPPER_FOR(PMPI_Wait)( MPI_Request* request, 1443ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown MPI_Status* status ) 1444ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown{ 1445ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown MPI_Request request_before; 1446ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown MPI_Status fake_status; 1447ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown OrigFn fn; 1448ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown int err; 1449ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown VALGRIND_GET_ORIG_FN(fn); 1450ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown before("Wait"); 1451ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (isMSI(status)) 1452ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown status = &fake_status; 1453ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown check_mem_is_addressable_untyped(status, sizeof(MPI_Status)); 1454ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown check_mem_is_defined_untyped(request, sizeof(MPI_Request)); 1455ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown request_before = *request; 1456b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_DISABLE_ERROR_REPORTING; 1457ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown CALL_FN_W_WW(err, fn, request,status); 1458b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_ENABLE_ERROR_REPORTING; 1459ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (err == MPI_SUCCESS) { 1460ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown maybe_complete(False/*err in status?*/, 1461ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown request_before, *request, status); 1462ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown make_mem_defined_if_addressable_untyped(status, sizeof(MPI_Status)); 1463ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 1464ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown after("Wait", err); 1465ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return err; 1466ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 1467ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1468ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* --- Waitany --- */ 1469ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownint WRAPPER_FOR(PMPI_Waitany)( int count, 1470ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown MPI_Request* requests, 1471ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown int* index, 1472ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown MPI_Status* status ) 1473ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown{ 1474ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown MPI_Request* requests_before = NULL; 1475ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown MPI_Status fake_status; 1476ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown OrigFn fn; 1477ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown int err, i; 1478ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown VALGRIND_GET_ORIG_FN(fn); 1479ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown before("Waitany"); 1480ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (isMSI(status)) 1481ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown status = &fake_status; 1482ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (0) fprintf(stderr, "Waitany: %d\n", count); 1483ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown check_mem_is_addressable_untyped(index, sizeof(int)); 1484ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown check_mem_is_addressable_untyped(status, sizeof(MPI_Status)); 1485ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown for (i = 0; i < count; i++) { 1486ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown check_mem_is_defined_untyped(&requests[i], sizeof(MPI_Request)); 1487ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 1488ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown requests_before = clone_Request_array( count, requests ); 1489b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_DISABLE_ERROR_REPORTING; 1490ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown CALL_FN_W_WWWW(err, fn, count,requests,index,status); 1491b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_ENABLE_ERROR_REPORTING; 1492ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (err == MPI_SUCCESS && *index >= 0 && *index < count) { 1493ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown maybe_complete(False/*err in status?*/, 1494ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown requests_before[*index], requests[*index], status); 1495ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown make_mem_defined_if_addressable_untyped(status, sizeof(MPI_Status)); 1496ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 1497ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (requests_before) 1498ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown free(requests_before); 1499ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown after("Waitany", err); 1500ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return err; 1501ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 1502ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1503ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* --- Waitall --- */ 1504ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownint WRAPPER_FOR(PMPI_Waitall)( int count, 1505ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown MPI_Request* requests, 1506ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown MPI_Status* statuses ) 1507ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown{ 1508ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown MPI_Request* requests_before = NULL; 1509ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown OrigFn fn; 1510ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown int err, i; 1511ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Bool free_sta = False; 1512ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown VALGRIND_GET_ORIG_FN(fn); 1513ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown before("Waitall"); 1514ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (0) fprintf(stderr, "Waitall: %d\n", count); 1515ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (isMSI(statuses)) { 1516ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown free_sta = True; 1517ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown statuses = malloc( (count < 0 ? 0 : count) * sizeof(MPI_Status) ); 1518ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 1519ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown for (i = 0; i < count; i++) { 1520ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown check_mem_is_addressable_untyped(&statuses[i], sizeof(MPI_Status)); 1521ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown check_mem_is_defined_untyped(&requests[i], sizeof(MPI_Request)); 1522ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 1523ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown requests_before = clone_Request_array( count, requests ); 1524b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_DISABLE_ERROR_REPORTING; 1525ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown CALL_FN_W_WWW(err, fn, count,requests,statuses); 1526b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_ENABLE_ERROR_REPORTING; 1527ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (err == MPI_SUCCESS /*complete success*/ 1528ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown || err == MPI_ERR_IN_STATUS /* partial success */) { 1529ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Bool e_i_s = err == MPI_ERR_IN_STATUS; 1530ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown for (i = 0; i < count; i++) { 1531ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown maybe_complete(e_i_s, requests_before[i], requests[i], 1532ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown &statuses[i]); 1533ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown make_mem_defined_if_addressable_untyped(&statuses[i], 1534ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown sizeof(MPI_Status)); 1535ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 1536ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 1537ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (requests_before) 1538ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown free(requests_before); 1539ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (free_sta) 1540ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown free(statuses); 1541ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown after("Waitall", err); 1542ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return err; 1543ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 1544ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1545ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* --- Test --- */ 1546ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* nonblocking version of Wait */ 1547ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownint WRAPPER_FOR(PMPI_Test)( MPI_Request* request, int* flag, 1548ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown MPI_Status* status ) 1549ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown{ 1550ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown MPI_Request request_before; 1551ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown MPI_Status fake_status; 1552ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown OrigFn fn; 1553ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown int err; 1554ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown VALGRIND_GET_ORIG_FN(fn); 1555ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown before("Test"); 1556ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (isMSI(status)) 1557ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown status = &fake_status; 1558ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown check_mem_is_addressable_untyped(status, sizeof(MPI_Status)); 1559ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown check_mem_is_addressable_untyped(flag, sizeof(int)); 1560ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown check_mem_is_defined_untyped(request, sizeof(MPI_Request)); 1561ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown request_before = *request; 1562b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_DISABLE_ERROR_REPORTING; 1563ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown CALL_FN_W_WWW(err, fn, request,flag,status); 1564b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_ENABLE_ERROR_REPORTING; 1565ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (err == MPI_SUCCESS && *flag) { 1566ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown maybe_complete(False/*err in status?*/, 1567ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown request_before, *request, status); 1568ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown make_mem_defined_if_addressable_untyped(status, sizeof(MPI_Status)); 1569ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 1570ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown after("Test", err); 1571ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return err; 1572ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 1573ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1574ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* --- Testall --- */ 1575ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* nonblocking version of Waitall */ 1576ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownint WRAPPER_FOR(PMPI_Testall)( int count, MPI_Request* requests, 1577ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown int* flag, MPI_Status* statuses ) 1578ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown{ 1579ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown MPI_Request* requests_before = NULL; 1580ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown OrigFn fn; 1581ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown int err, i; 1582ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Bool free_sta = False; 1583ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown VALGRIND_GET_ORIG_FN(fn); 1584ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown before("Testall"); 1585ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (0) fprintf(stderr, "Testall: %d\n", count); 1586ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (isMSI(statuses)) { 1587ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown free_sta = True; 1588ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown statuses = malloc( (count < 0 ? 0 : count) * sizeof(MPI_Status) ); 1589ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 1590ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown check_mem_is_addressable_untyped(flag, sizeof(int)); 1591ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown for (i = 0; i < count; i++) { 1592ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown check_mem_is_addressable_untyped(&statuses[i], sizeof(MPI_Status)); 1593ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown check_mem_is_defined_untyped(&requests[i], sizeof(MPI_Request)); 1594ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 1595ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown requests_before = clone_Request_array( count, requests ); 1596b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_DISABLE_ERROR_REPORTING; 1597ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown CALL_FN_W_WWWW(err, fn, count,requests,flag,statuses); 1598b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_ENABLE_ERROR_REPORTING; 1599ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown /* Urk. Is the following "if (...)" really right? I don't know. */ 1600ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (*flag 1601ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown && (err == MPI_SUCCESS /*complete success*/ 1602ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown || err == MPI_ERR_IN_STATUS /* partial success */)) { 1603ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Bool e_i_s = err == MPI_ERR_IN_STATUS; 1604ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown for (i = 0; i < count; i++) { 1605ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown maybe_complete(e_i_s, requests_before[i], requests[i], 1606ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown &statuses[i]); 1607ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown make_mem_defined_if_addressable_untyped(&statuses[i], 1608ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown sizeof(MPI_Status)); 1609ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 1610ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 1611ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (requests_before) 1612ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown free(requests_before); 1613ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (free_sta) 1614ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown free(statuses); 1615ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown after("Testall", err); 1616ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return err; 1617ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 1618ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1619ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* --- Iprobe --- */ 1620ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* pre: must-be-writable: *flag, *status */ 1621ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* post: make-readable *flag 1622ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if *flag==True make-defined *status */ 1623ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownint WRAPPER_FOR(PMPI_Iprobe)(int source, int tag, 1624ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown MPI_Comm comm, 1625ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown int* flag, MPI_Status* status) 1626ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown{ 1627ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown MPI_Status fake_status; 1628ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown OrigFn fn; 1629ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown int err; 1630ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown VALGRIND_GET_ORIG_FN(fn); 1631ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown before("Iprobe"); 1632ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (isMSI(status)) 1633ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown status = &fake_status; 1634ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown check_mem_is_addressable_untyped(flag, sizeof(*flag)); 1635ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown check_mem_is_addressable_untyped(status, sizeof(*status)); 1636b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_DISABLE_ERROR_REPORTING; 1637ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown CALL_FN_W_5W(err, fn, source,tag,comm,flag,status); 1638b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_ENABLE_ERROR_REPORTING; 1639ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (err == MPI_SUCCESS) { 1640ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown make_mem_defined_if_addressable_untyped(flag, sizeof(*flag)); 1641ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (*flag) 1642ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown make_mem_defined_if_addressable_untyped(status, sizeof(*status)); 1643ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 1644ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown after("Iprobe", err); 1645ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return err; 1646ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 1647ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1648ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* --- Probe --- */ 1649ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* pre: must-be-writable *status */ 1650ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* post: make-defined *status */ 1651ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownint WRAPPER_FOR(PMPI_Probe)(int source, int tag, 1652ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown MPI_Comm comm, MPI_Status* status) 1653ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown{ 1654ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown MPI_Status fake_status; 1655ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown OrigFn fn; 1656ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown int err; 1657ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown VALGRIND_GET_ORIG_FN(fn); 1658ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown before("Probe"); 1659ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (isMSI(status)) 1660ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown status = &fake_status; 1661ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown check_mem_is_addressable_untyped(status, sizeof(*status)); 1662b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_DISABLE_ERROR_REPORTING; 1663ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown CALL_FN_W_WWWW(err, fn, source,tag,comm,status); 1664b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_ENABLE_ERROR_REPORTING; 1665ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown make_mem_defined_if_addressable_if_success_untyped(err, status, sizeof(*status)); 1666ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown after("Probe", err); 1667ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return err; 1668ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 1669ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1670ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* --- Cancel --- */ 1671ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* Wrapping PMPI_Cancel is interesting only to the extent that we need 1672ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown to be able to detect when a request should be removed from our 1673ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown shadow table due to cancellation. */ 1674ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownint WRAPPER_FOR(PMPI_Cancel)(MPI_Request* request) 1675ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown{ 1676ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown OrigFn fn; 1677ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown int err; 1678ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown MPI_Request tmp; 1679ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown VALGRIND_GET_ORIG_FN(fn); 1680ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown before("Cancel"); 1681ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown check_mem_is_addressable_untyped(request, sizeof(*request)); 1682ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown tmp = *request; 1683b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_DISABLE_ERROR_REPORTING; 1684ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown CALL_FN_W_W(err, fn, request); 1685b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_ENABLE_ERROR_REPORTING; 1686ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (err == MPI_SUCCESS) 1687ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown delete_shadow_Request(tmp); 1688ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown after("Cancel", err); 1689ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return err; 1690ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 1691ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1692ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1693ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*------------------------------------------------------------*/ 1694ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*--- ---*/ 1695ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*--- Sec 3.10, Send-receive ---*/ 1696ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*--- ---*/ 1697ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*------------------------------------------------------------*/ 1698ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1699ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* --- Sendrecv --- */ 1700ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* pre: must be readable: (sendbuf,sendcount,sendtype) 1701ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown must be writable: (recvbuf,recvcount,recvtype) 1702ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown post: make readable: (recvbuf,recvcount_actual,datatype) 1703ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown where recvcount_actual is determined from *status 1704ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown*/ 1705ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownint WRAPPER_FOR(PMPI_Sendrecv)( 1706ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown void *sendbuf, int sendcount, MPI_Datatype sendtype, 1707ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown int dest, int sendtag, 1708ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown void *recvbuf, int recvcount, MPI_Datatype recvtype, 1709ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown int source, int recvtag, 1710ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown MPI_Comm comm, MPI_Status *status) 1711ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown{ 1712ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown MPI_Status fake_status; 1713ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown OrigFn fn; 1714ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown int err, recvcount_actual = 0; 1715ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown VALGRIND_GET_ORIG_FN(fn); 1716ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown before("Sendrecv"); 1717ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (isMSI(status)) 1718ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown status = &fake_status; 1719ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown check_mem_is_defined(sendbuf, sendcount, sendtype); 1720ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown check_mem_is_addressable(recvbuf, recvcount, recvtype); 1721ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown check_mem_is_addressable_untyped(status, sizeof(*status)); 1722b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_DISABLE_ERROR_REPORTING; 1723ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown CALL_FN_W_12W(err, fn, sendbuf,sendcount,sendtype,dest,sendtag, 1724ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown recvbuf,recvcount,recvtype,source,recvtag, 1725ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown comm,status); 1726b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_ENABLE_ERROR_REPORTING; 1727ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (err == MPI_SUCCESS 1728ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown && count_from_Status(&recvcount_actual,recvtype,status)) { 1729ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown make_mem_defined_if_addressable(recvbuf, recvcount_actual, recvtype); 1730ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 1731ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown after("Sendrecv", err); 1732ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return err; 1733ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 1734ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1735ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1736ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*------------------------------------------------------------*/ 1737ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*--- ---*/ 1738ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*--- Sec 3.12, Derived datatypes ---*/ 1739ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*--- ---*/ 1740ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*------------------------------------------------------------*/ 1741ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1742ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* --- Address --- */ 1743ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* Does this have anything worth checking? */ 1744ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownHAS_NO_WRAPPER(Address) 1745ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1746ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* --- MPI 2 stuff --- */ 1747ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* Type_extent, Type_get_contents and Type_get_envelope sometimes get 1748ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown used intensively by the type walker (walk_type). There's no reason 1749ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown why they couldn't be properly wrapped if needed, but doing so slows 1750ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown everything down, so don't bother until needed. */ 1751ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownHAS_NO_WRAPPER(Type_extent) 1752ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownHAS_NO_WRAPPER(Type_get_contents) 1753ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownHAS_NO_WRAPPER(Type_get_envelope) 1754ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1755ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* --- Type_commit --- */ 1756ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownint WRAPPER_FOR(PMPI_Type_commit)( MPI_Datatype* ty ) 1757ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown{ 1758ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown OrigFn fn; 1759ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown int err; 1760ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown VALGRIND_GET_ORIG_FN(fn); 1761ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown before("Type_commit"); 1762ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown check_mem_is_defined_untyped(ty, sizeof(*ty)); 1763b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_DISABLE_ERROR_REPORTING; 1764ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown CALL_FN_W_W(err, fn, ty); 1765b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_ENABLE_ERROR_REPORTING; 1766ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown after("Type_commit", err); 1767ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return err; 1768ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 1769ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1770ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* --- Type_free --- */ 1771ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownint WRAPPER_FOR(PMPI_Type_free)( MPI_Datatype* ty ) 1772ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown{ 1773ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown OrigFn fn; 1774ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown int err; 1775ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown VALGRIND_GET_ORIG_FN(fn); 1776ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown before("Type_free"); 1777ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown check_mem_is_defined_untyped(ty, sizeof(*ty)); 1778b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_DISABLE_ERROR_REPORTING; 1779ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown CALL_FN_W_W(err, fn, ty); 1780b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_ENABLE_ERROR_REPORTING; 1781ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown after("Type_free", err); 1782ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return err; 1783ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 1784ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1785ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1786ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*------------------------------------------------------------*/ 1787ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*--- ---*/ 1788ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*--- Sec 3.13, Pack and unpack ---*/ 1789ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*--- ---*/ 1790ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*------------------------------------------------------------*/ 1791ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1792ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* --- Pack --- */ 1793ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* pre: must be readable: position 1794ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown must be readable: (inbuf,incount,datatype) 1795ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown must be writable: outbuf[0 .. outsize-1] 1796ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown must be writable: outbuf[*position .. 1797ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown *position - 1 1798ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown + however much space PMPI_Pack_size 1799ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown says we will need] 1800ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown post: make readable: outbuf[old *position .. new *position] 1801ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown*/ 1802ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownint WRAPPER_FOR(PMPI_Pack)( void* inbuf, int incount, MPI_Datatype datatype, 1803ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown void* outbuf, int outsize, 1804ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown int* position, MPI_Comm comm ) 1805ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown{ 1806ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown OrigFn fn; 1807ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown int err, szB = 0; 1808ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown int position_ORIG = *position; 1809ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown VALGRIND_GET_ORIG_FN(fn); 1810ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown before("Pack"); 1811ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown /* stay sane */ 1812ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown check_mem_is_defined_untyped(position, sizeof(*position)); 1813ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown /* check input */ 1814ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown check_mem_is_defined(inbuf, incount, datatype); 1815ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown /* check output area's stated bounds make sense */ 1816ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown check_mem_is_addressable_untyped(outbuf, outsize); 1817ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown /* check output area's actual used size properly */ 1818ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown err = PMPI_Pack_size( incount, datatype, comm, &szB ); 1819ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (err == MPI_SUCCESS && szB > 0) { 1820ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown check_mem_is_addressable_untyped( 1821ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown ((char*)outbuf) + position_ORIG, szB 1822ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown ); 1823ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 1824ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1825b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_DISABLE_ERROR_REPORTING; 1826ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown CALL_FN_W_7W(err, fn, inbuf,incount,datatype, outbuf,outsize,position, comm); 1827b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_ENABLE_ERROR_REPORTING; 1828ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1829ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (err == MPI_SUCCESS && (*position) > position_ORIG) { 1830ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown /* paint output */ 1831ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown make_mem_defined_if_addressable_untyped( 1832ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown ((char*)outbuf) + position_ORIG, *position - position_ORIG 1833ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown ); 1834ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 1835ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown after("Pack", err); 1836ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return err; 1837ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 1838ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1839ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* --- Unpack --- */ 1840ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* pre: must be readable: position 1841ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown must be writable: (outbuf,outcount,datatype) 1842ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown must be writable: outbuf[0 .. outsize-1] 1843ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown must be writable: outbuf[*position .. 1844ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown *position - 1 1845ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown + however much space PMPI_Pack_size 1846ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown says we will need] 1847ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown post: make readable: (outbuf,outcount,datatype) 1848ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown and also do a readability check of 1849ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown inbuf[old *position .. new *position] 1850ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown*/ 1851ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownint WRAPPER_FOR(PMPI_Unpack)( void* inbuf, int insize, int* position, 1852ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown void* outbuf, int outcount, MPI_Datatype datatype, 1853ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown MPI_Comm comm ) 1854ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown{ 1855ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown OrigFn fn; 1856ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown int err, szB = 0; 1857ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown int position_ORIG = *position; 1858ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown VALGRIND_GET_ORIG_FN(fn); 1859ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown before("Unpack"); 1860ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown /* stay sane */ 1861ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown check_mem_is_defined_untyped(position, sizeof(*position)); 1862ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown /* check output area is accessible */ 1863ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown check_mem_is_addressable(outbuf, outcount, datatype); 1864ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown /* check input area's stated bounds make sense */ 1865ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown check_mem_is_addressable_untyped(inbuf, insize); 1866ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown /* check input area's actual used size properly */ 1867ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown err = PMPI_Pack_size( outcount, datatype, comm, &szB ); 1868ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (err == MPI_SUCCESS && szB > 0) { 1869ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown check_mem_is_addressable_untyped( 1870ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown ((char*)inbuf) + position_ORIG, szB 1871ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown ); 1872ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 1873ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1874b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_DISABLE_ERROR_REPORTING; 1875ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown CALL_FN_W_7W(err, fn, inbuf,insize,position, outbuf,outcount,datatype, comm); 1876b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_ENABLE_ERROR_REPORTING; 1877ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1878ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (err == MPI_SUCCESS && (*position) > position_ORIG) { 1879ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown /* recheck input more carefully */ 1880ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown check_mem_is_defined_untyped( 1881ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown ((char*)inbuf) + position_ORIG, *position - position_ORIG 1882ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown ); 1883ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown /* paint output */ 1884ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown make_mem_defined_if_addressable( outbuf, outcount, datatype ); 1885ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 1886ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown after("Unpack", err); 1887ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return err; 1888ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 1889ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1890ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1891ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*------------------------------------------------------------*/ 1892ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*--- ---*/ 1893ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*--- Sec 4.4, Broadcast ---*/ 1894ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*--- ---*/ 1895ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*------------------------------------------------------------*/ 1896ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1897ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* --- Bcast --- */ 1898ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* pre: must-be-readable (buffer,count,datatype) for rank==root 1899ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown must-be-writable (buffer,count,datatype) for rank!=root 1900ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown post: make-readable (buffer,count,datatype) for all 1901ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1902ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Resulting behaviour is: if root sends uninitialised stuff, then 1903ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown V complains, but then all ranks, including itself, see the buffer 1904ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown as initialised after that. 1905ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown*/ 1906ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownint WRAPPER_FOR(PMPI_Bcast)(void *buffer, int count, 1907ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown MPI_Datatype datatype, 1908ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown int root, MPI_Comm comm) 1909ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown{ 1910ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown OrigFn fn; 1911ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown int err; 1912ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Bool i_am_sender; 1913ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown VALGRIND_GET_ORIG_FN(fn); 1914ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown before("Bcast"); 1915ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown i_am_sender = root == comm_rank(comm); 1916ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (i_am_sender) { 1917ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown check_mem_is_defined(buffer, count, datatype); 1918ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } else { 1919ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown check_mem_is_addressable(buffer, count, datatype); 1920ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 1921b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_DISABLE_ERROR_REPORTING; 1922ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown CALL_FN_W_5W(err, fn, buffer,count,datatype,root,comm); 1923b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_ENABLE_ERROR_REPORTING; 1924ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown make_mem_defined_if_addressable_if_success(err, buffer, count, datatype); 1925ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown after("Bcast", err); 1926ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return err; 1927ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 1928ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1929ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1930ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*------------------------------------------------------------*/ 1931ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*--- ---*/ 1932ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*--- Sec 4.5, Gather ---*/ 1933ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*--- ---*/ 1934ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*------------------------------------------------------------*/ 1935ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1936ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* --- Gather --- */ 1937ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* JRS 20060217: I don't really understand this. Each process is 1938ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown going to send sendcount items of type sendtype to the root. So 1939ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown the root is going to receive comm_size*sendcount items of type 1940ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown sendtype (right?) So why specify recvcount and recvtype? 1941ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1942ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Anyway, assuming the MPI Spec is correct (seems likely :-) we have: 1943ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1944ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown pre: (all) must be readable: (sendbuf,sendcount,sendtype) 1945ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown (root only): must be writable: (recvbuf,recvcount * comm_size,recvtype) 1946ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown post: (root only): make readable: (recvbuf,recvcount * comm_size,recvtype) 1947ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown*/ 1948ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownint WRAPPER_FOR(PMPI_Gather)( 1949ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown void *sendbuf, int sendcount, MPI_Datatype sendtype, 1950ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown void *recvbuf, int recvcount, MPI_Datatype recvtype, 1951ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown int root, MPI_Comm comm) 1952ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown{ 1953ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown OrigFn fn; 1954ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown int err, me, sz; 1955ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown VALGRIND_GET_ORIG_FN(fn); 1956ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown before("Gather"); 1957ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown me = comm_rank(comm); 1958ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown sz = comm_size(comm); 1959ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown check_mem_is_defined(sendbuf, sendcount, sendtype); 1960ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (me == root) 1961ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown check_mem_is_addressable(recvbuf, recvcount * sz, recvtype); 1962b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_DISABLE_ERROR_REPORTING; 1963ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown CALL_FN_W_8W(err, fn, sendbuf,sendcount,sendtype, 1964ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown recvbuf,recvcount,recvtype, 1965ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown root,comm); 1966b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_ENABLE_ERROR_REPORTING; 1967ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (me == root) 1968ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown make_mem_defined_if_addressable_if_success(err, recvbuf, recvcount * sz, recvtype); 1969ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown after("Gather", err); 1970ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return err; 1971ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 1972ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1973ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1974ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*------------------------------------------------------------*/ 1975ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*--- ---*/ 1976ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*--- Sec 4.6, Scatter ---*/ 1977ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*--- ---*/ 1978ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*------------------------------------------------------------*/ 1979ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1980ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* pre: (root only): must be readable: (sendbuf,sendcount * comm_size,sendtype) 1981ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown (all): must be writable: (recvbuf,recvbuf,recvtype) 1982ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown post: (all): make defined: (recvbuf,recvbuf,recvtype) 1983ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown*/ 1984ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownint WRAPPER_FOR(PMPI_Scatter)( 1985ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown void* sendbuf, int sendcount, MPI_Datatype sendtype, 1986ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown void* recvbuf, int recvcount, MPI_Datatype recvtype, 1987ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown int root, MPI_Comm comm) 1988ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown{ 1989ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown OrigFn fn; 1990ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown int err, me, sz; 1991ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown VALGRIND_GET_ORIG_FN(fn); 1992ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown before("Scatter"); 1993ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown me = comm_rank(comm); 1994ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown sz = comm_size(comm); 1995ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown check_mem_is_addressable(recvbuf, recvcount, recvtype); 1996ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (me == root) 1997ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown check_mem_is_defined(sendbuf, sendcount * sz, sendtype); 1998b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_DISABLE_ERROR_REPORTING; 1999ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown CALL_FN_W_8W(err, fn, sendbuf,sendcount,sendtype, 2000ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown recvbuf,recvcount,recvtype, 2001ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown root,comm); 2002b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_ENABLE_ERROR_REPORTING; 2003ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown make_mem_defined_if_addressable_if_success(err, recvbuf, recvcount, recvtype); 2004ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown after("Scatter", err); 2005ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return err; 2006ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 2007ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 2008ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 2009ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*------------------------------------------------------------*/ 2010ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*--- ---*/ 2011ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*--- Sec 4.8, All-to-All Scatter/Gather ---*/ 2012ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*--- ---*/ 2013ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*------------------------------------------------------------*/ 2014ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 2015ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* pre: (all) must be readable: (sendbuf,sendcount * comm_size,sendtype) 2016ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown (all) must be writable: (recvbuf,recvcount * comm_size,recvtype) 2017ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown post: (all) make defined: (recvbuf,recvcount * comm_size,recvtype) 2018ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown*/ 2019ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownint WRAPPER_FOR(PMPI_Alltoall)( 2020ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown void* sendbuf, int sendcount, MPI_Datatype sendtype, 2021ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown void* recvbuf, int recvcount, MPI_Datatype recvtype, 2022ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown MPI_Comm comm) 2023ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown{ 2024ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown OrigFn fn; 2025ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown int err, sz; 2026ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown VALGRIND_GET_ORIG_FN(fn); 2027ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown before("Alltoall"); 2028ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown sz = comm_size(comm); 2029ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown check_mem_is_defined(sendbuf, sendcount * sz, sendtype); 2030ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown check_mem_is_addressable(recvbuf, recvcount * sz, recvtype); 2031b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_DISABLE_ERROR_REPORTING; 2032ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown CALL_FN_W_7W(err, fn, sendbuf,sendcount,sendtype, 2033ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown recvbuf,recvcount,recvtype, 2034ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown comm); 2035b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_ENABLE_ERROR_REPORTING; 2036ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown make_mem_defined_if_addressable_if_success(err, recvbuf, recvcount * sz, recvtype); 2037ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown after("Alltoall", err); 2038ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return err; 2039ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 2040ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 2041ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 2042ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*------------------------------------------------------------*/ 2043ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*--- ---*/ 2044ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*--- Sec 4.9, Global Reduction Operations ---*/ 2045ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*--- ---*/ 2046ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*------------------------------------------------------------*/ 2047ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 2048ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* --- Reduce --- */ 2049ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* rd: (sendbuf,count,datatype) for all 2050ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown wr: (recvbuf,count,datatype) but only for rank == root 2051ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown*/ 2052ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownint WRAPPER_FOR(PMPI_Reduce)(void *sendbuf, void *recvbuf, 2053ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown int count, 2054ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown MPI_Datatype datatype, MPI_Op op, 2055ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown int root, MPI_Comm comm) 2056ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown{ 2057ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown OrigFn fn; 2058ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown int err; 2059ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Bool i_am_root; 2060ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown VALGRIND_GET_ORIG_FN(fn); 2061ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown before("Reduce"); 2062ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown i_am_root = root == comm_rank(comm); 2063ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown check_mem_is_defined(sendbuf, count, datatype); 2064ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (i_am_root) 2065ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown check_mem_is_addressable(recvbuf, count, datatype); 2066b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_DISABLE_ERROR_REPORTING; 2067ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown CALL_FN_W_7W(err, fn, sendbuf,recvbuf,count,datatype,op,root,comm); 2068b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_ENABLE_ERROR_REPORTING; 2069ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (i_am_root) 2070ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown make_mem_defined_if_addressable_if_success(err, recvbuf, count, datatype); 2071ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown after("Reduce", err); 2072ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return err; 2073ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 2074ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 2075ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 2076ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* --- Allreduce --- */ 2077ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* rd: (sendbuf,count,datatype) for all 2078ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown wr: (recvbuf,count,datatype) for all 2079ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown*/ 2080ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownint WRAPPER_FOR(PMPI_Allreduce)(void *sendbuf, void *recvbuf, 2081ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown int count, 2082ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown MPI_Datatype datatype, MPI_Op op, 2083ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown MPI_Comm comm) 2084ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown{ 2085ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown OrigFn fn; 2086ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown int err; 2087ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown VALGRIND_GET_ORIG_FN(fn); 2088ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown before("Allreduce"); 2089ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown check_mem_is_defined(sendbuf, count, datatype); 2090ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown check_mem_is_addressable(recvbuf, count, datatype); 2091b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_DISABLE_ERROR_REPORTING; 2092ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown CALL_FN_W_6W(err, fn, sendbuf,recvbuf,count,datatype,op,comm); 2093b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_ENABLE_ERROR_REPORTING; 2094ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown make_mem_defined_if_addressable_if_success(err, recvbuf, count, datatype); 2095ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown after("Allreduce", err); 2096ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return err; 2097ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 2098ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 2099ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 2100ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* --- Op_create --- */ 2101ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* This is a bit dubious. I suppose it takes 'function' and 2102ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown writes something at *op, but who knows what an MPI_Op is? 2103ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown Can we safely do 'sizeof' on it? */ 2104ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownint WRAPPER_FOR(PMPI_Op_create)( MPI_User_function* function, 2105ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown int commute, 2106ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown MPI_Op* op ) 2107ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown{ 2108ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown OrigFn fn; 2109ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown int err; 2110ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown VALGRIND_GET_ORIG_FN(fn); 2111ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown before("Op_create"); 2112ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown check_mem_is_addressable_untyped(op, sizeof(*op)); 2113b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_DISABLE_ERROR_REPORTING; 2114ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown CALL_FN_W_WWW(err, fn, function,commute,op); 2115b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_ENABLE_ERROR_REPORTING; 2116ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown make_mem_defined_if_addressable_if_success_untyped(err, op, sizeof(*op)); 2117ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown after("Op_create", err); 2118ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return err; 2119ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 2120ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 2121ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 2122ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*------------------------------------------------------------*/ 2123ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*--- ---*/ 2124ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*--- Sec 5.4, Communicator management ---*/ 2125ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*--- ---*/ 2126ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*------------------------------------------------------------*/ 2127ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 2128ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* Hardly seems worth wrapping Comm_rank and Comm_size, but 2129ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown since it's done now .. */ 2130ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 2131ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* --- Comm_create --- */ 2132ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* Let normal memcheck tracking handle this. */ 2133ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownint WRAPPER_FOR(PMPI_Comm_create)(MPI_Comm comm, MPI_Group group, 2134ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown MPI_Comm* newcomm) 2135ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown{ 2136ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown OrigFn fn; 2137ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown int err; 2138ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown VALGRIND_GET_ORIG_FN(fn); 2139ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown before("Comm_create"); 2140b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_DISABLE_ERROR_REPORTING; 2141ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown CALL_FN_W_WWW(err, fn, comm,group,newcomm); 2142b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_ENABLE_ERROR_REPORTING; 2143ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown after("Comm_create", err); 2144ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return err; 2145ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 2146ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 2147ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* --- Comm_dup --- */ 2148ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* Let normal memcheck tracking handle this. */ 2149ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownint WRAPPER_FOR(PMPI_Comm_dup)(MPI_Comm comm, MPI_Comm* newcomm) 2150ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown{ 2151ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown OrigFn fn; 2152ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown int err; 2153ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown VALGRIND_GET_ORIG_FN(fn); 2154ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown before("Comm_dup"); 2155b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_DISABLE_ERROR_REPORTING; 2156ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown CALL_FN_W_WW(err, fn, comm,newcomm); 2157b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_ENABLE_ERROR_REPORTING; 2158ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown after("Comm_dup", err); 2159ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return err; 2160ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 2161ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 2162ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* --- Comm_free --- */ 2163ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* Let normal memcheck tracking handle this. */ 2164ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownint WRAPPER_FOR(PMPI_Comm_free)(MPI_Comm* comm) 2165ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown{ 2166ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown OrigFn fn; 2167ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown int err; 2168ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown VALGRIND_GET_ORIG_FN(fn); 2169ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown before("Comm_free"); 2170b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_DISABLE_ERROR_REPORTING; 2171ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown CALL_FN_W_W(err, fn, comm); 2172b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_ENABLE_ERROR_REPORTING; 2173ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown after("Comm_free", err); 2174ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return err; 2175ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 2176ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 2177ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* --- Comm_rank --- */ 2178ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* wr: (rank, sizeof(*rank)) */ 2179ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownint WRAPPER_FOR(PMPI_Comm_rank)(MPI_Comm comm, int *rank) 2180ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown{ 2181ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown OrigFn fn; 2182ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown int err; 2183ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown VALGRIND_GET_ORIG_FN(fn); 2184ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown before("Comm_rank"); 2185ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown check_mem_is_addressable_untyped(rank, sizeof(*rank)); 2186b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_DISABLE_ERROR_REPORTING; 2187ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown CALL_FN_W_WW(err, fn, comm,rank); 2188b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_ENABLE_ERROR_REPORTING; 2189ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown make_mem_defined_if_addressable_if_success_untyped(err, rank, sizeof(*rank)); 2190ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown after("Comm_rank", err); 2191ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return err; 2192ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 2193ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 2194ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* --- Comm_size --- */ 2195ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* wr: (size, sizeof(*size)) */ 2196ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownint WRAPPER_FOR(PMPI_Comm_size)(MPI_Comm comm, int *size) 2197ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown{ 2198ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown OrigFn fn; 2199ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown int err; 2200ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown VALGRIND_GET_ORIG_FN(fn); 2201ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown before("Comm_size"); 2202ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown check_mem_is_addressable_untyped(size, sizeof(*size)); 2203b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_DISABLE_ERROR_REPORTING; 2204ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown CALL_FN_W_WW(err, fn, comm,size); 2205b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_ENABLE_ERROR_REPORTING; 2206ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown make_mem_defined_if_addressable_if_success_untyped(err, size, sizeof(*size)); 2207ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown after("Comm_size", err); 2208ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return err; 2209ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 2210ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 2211ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 2212ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*------------------------------------------------------------*/ 2213ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*--- ---*/ 2214ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*--- Sec 5.7, Caching ---*/ 2215ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*--- ---*/ 2216ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*------------------------------------------------------------*/ 2217ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 2218ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 2219ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*------------------------------------------------------------*/ 2220ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*--- ---*/ 2221ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*--- Sec 7.3, Error codes and classes ---*/ 2222ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*--- ---*/ 2223ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*------------------------------------------------------------*/ 2224ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 2225ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* --- Error_string --- */ 2226ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownint WRAPPER_FOR(PMPI_Error_string)( int errorcode, char* string, 2227ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown int* resultlen ) 2228ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown{ 2229ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown OrigFn fn; 2230ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown int err; 2231ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown VALGRIND_GET_ORIG_FN(fn); 2232ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown before("Error_string"); 2233ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown check_mem_is_addressable_untyped(resultlen, sizeof(int)); 2234ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown check_mem_is_addressable_untyped(string, MPI_MAX_ERROR_STRING); 2235b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_DISABLE_ERROR_REPORTING; 2236ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown CALL_FN_W_WWW(err, fn, errorcode,string,resultlen); 2237b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_ENABLE_ERROR_REPORTING; 2238ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown /* Don't bother to paint the result; we assume the real function 2239ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown will have filled it with defined characters :-) */ 2240ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown after("Error_string", err); 2241ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return err; 2242ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 2243ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 2244ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 2245ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*------------------------------------------------------------*/ 2246ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*--- ---*/ 2247ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*--- Sec 7.5, Startup ---*/ 2248ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*--- ---*/ 2249ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*------------------------------------------------------------*/ 2250ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 2251ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* --- Init --- */ 2252ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* rd: *argc, *argv[0 .. *argc-1] */ 2253ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownlong WRAPPER_FOR(PMPI_Init)(int *argc, char ***argv) 2254ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown{ 2255ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown OrigFn fn; 2256ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown int err; 2257ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown VALGRIND_GET_ORIG_FN(fn); 2258ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown before("Init"); 2259ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (argc) { 2260ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown check_mem_is_defined_untyped(argc, sizeof(int)); 2261ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 2262ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (argc && argv) { 2263ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown check_mem_is_defined_untyped(*argv, *argc * sizeof(char**)); 2264ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 2265b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_DISABLE_ERROR_REPORTING; 2266ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown CALL_FN_W_WW(err, fn, argc,argv); 2267b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_ENABLE_ERROR_REPORTING; 2268ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown after("Init", err); 2269ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (opt_initkludge) 2270ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return (long)(void*)&mpiwrap_walk_type_EXTERNALLY_VISIBLE; 2271ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown else 2272ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return (long)err; 2273ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 2274ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 2275ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* --- Initialized --- */ 2276ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownint WRAPPER_FOR(PMPI_Initialized)(int* flag) 2277ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown{ 2278ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown OrigFn fn; 2279ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown int err; 2280ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown VALGRIND_GET_ORIG_FN(fn); 2281ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown before("Initialized"); 2282ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown check_mem_is_addressable_untyped(flag, sizeof(int)); 2283b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_DISABLE_ERROR_REPORTING; 2284ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown CALL_FN_W_W(err, fn, flag); 2285b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_ENABLE_ERROR_REPORTING; 2286ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown make_mem_defined_if_addressable_if_success_untyped(err, flag, sizeof(int)); 2287ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown after("Initialized", err); 2288ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return err; 2289ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 2290ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 2291ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* --- Finalize --- */ 2292ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brownint WRAPPER_FOR(PMPI_Finalize)(void) 2293ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown{ 2294ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown OrigFn fn; 2295ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown int err; 2296ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown VALGRIND_GET_ORIG_FN(fn); 2297ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown before("Finalize"); 2298b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_DISABLE_ERROR_REPORTING; 2299ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown CALL_FN_W_v(err, fn); 2300b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_ENABLE_ERROR_REPORTING; 2301ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown after("Finalize", err); 2302ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return err; 2303ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown} 2304ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 2305ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 2306ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*------------------------------------------------------------*/ 2307ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*--- ---*/ 2308ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*--- Default wrappers for all remaining functions ---*/ 2309ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*--- ---*/ 2310ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*------------------------------------------------------------*/ 2311ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 2312ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* Boilerplate for default wrappers. */ 2313ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown#define DEFAULT_WRAPPER_PREAMBLE(basename) \ 2314ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown OrigFn fn; \ 2315ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown UWord res; \ 2316ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown static int complaints = 1; \ 2317ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown VALGRIND_GET_ORIG_FN(fn); \ 2318ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown before(#basename); \ 2319ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (opt_missing >= 2) { \ 2320ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown barf("no wrapper for PMPI_" #basename \ 2321ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown ",\n\t\t\t and you have " \ 2322ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown "requested strict checking"); \ 2323ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } \ 2324ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown if (opt_missing == 1 && complaints > 0) { \ 2325ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown fprintf(stderr, "%s %5d: warning: no wrapper " \ 2326ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown "for PMPI_" #basename "\n", \ 2327ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown preamble, my_pid); \ 2328ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown complaints--; \ 2329ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } \ 2330ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 2331ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown#define DEFAULT_WRAPPER_W_0W(basename) \ 2332ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown UWord WRAPPER_FOR(PMPI_##basename)( void ) \ 2333ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown { \ 2334ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown DEFAULT_WRAPPER_PREAMBLE(basename) \ 2335b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_DISABLE_ERROR_REPORTING; \ 2336ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown CALL_FN_W_v(res, fn); \ 2337b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_ENABLE_ERROR_REPORTING; \ 2338ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return res; \ 2339ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 2340ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 2341ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown#define DEFAULT_WRAPPER_W_1W(basename) \ 2342ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown UWord WRAPPER_FOR(PMPI_##basename)( UWord a1 ) \ 2343ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown { \ 2344ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown DEFAULT_WRAPPER_PREAMBLE(basename) \ 2345b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_DISABLE_ERROR_REPORTING; \ 2346ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown CALL_FN_W_W(res, fn, a1); \ 2347b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_ENABLE_ERROR_REPORTING; \ 2348ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return res; \ 2349ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 2350ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 2351ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown#define DEFAULT_WRAPPER_W_2W(basename) \ 2352ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown UWord WRAPPER_FOR(PMPI_##basename)( UWord a1, UWord a2 ) \ 2353ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown { \ 2354ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown DEFAULT_WRAPPER_PREAMBLE(basename) \ 2355b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_DISABLE_ERROR_REPORTING; \ 2356ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown CALL_FN_W_WW(res, fn, a1,a2); \ 2357b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_ENABLE_ERROR_REPORTING; \ 2358ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return res; \ 2359ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 2360ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 2361ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown#define DEFAULT_WRAPPER_W_3W(basename) \ 2362ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown UWord WRAPPER_FOR(PMPI_##basename) \ 2363ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown ( UWord a1, UWord a2, UWord a3 ) \ 2364ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown { \ 2365ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown DEFAULT_WRAPPER_PREAMBLE(basename) \ 2366b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_DISABLE_ERROR_REPORTING; \ 2367ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown CALL_FN_W_WWW(res, fn, a1,a2,a3); \ 2368b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_ENABLE_ERROR_REPORTING; \ 2369ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return res; \ 2370ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 2371ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 2372ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown#define DEFAULT_WRAPPER_W_4W(basename) \ 2373ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown UWord WRAPPER_FOR(PMPI_##basename) \ 2374ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown ( UWord a1, UWord a2, UWord a3, UWord a4 ) \ 2375ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown { \ 2376ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown DEFAULT_WRAPPER_PREAMBLE(basename) \ 2377b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_DISABLE_ERROR_REPORTING; \ 2378ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown CALL_FN_W_WWWW(res, fn, a1,a2,a3,a4); \ 2379b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_ENABLE_ERROR_REPORTING; \ 2380ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return res; \ 2381ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 2382ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 2383ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown#define DEFAULT_WRAPPER_W_5W(basename) \ 2384ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown UWord WRAPPER_FOR(PMPI_##basename) \ 2385ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown ( UWord a1, UWord a2, UWord a3, UWord a4, UWord a5 ) \ 2386ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown { \ 2387ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown DEFAULT_WRAPPER_PREAMBLE(basename) \ 2388b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_DISABLE_ERROR_REPORTING; \ 2389ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown CALL_FN_W_5W(res, fn, a1,a2,a3,a4,a5); \ 2390b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_ENABLE_ERROR_REPORTING; \ 2391ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return res; \ 2392ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 2393ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 2394ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown#define DEFAULT_WRAPPER_W_6W(basename) \ 2395ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown UWord WRAPPER_FOR(PMPI_##basename) \ 2396ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown ( UWord a1, UWord a2, UWord a3, UWord a4, UWord a5, \ 2397ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown UWord a6 ) \ 2398ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown { \ 2399ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown DEFAULT_WRAPPER_PREAMBLE(basename) \ 2400b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_DISABLE_ERROR_REPORTING; \ 2401ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown CALL_FN_W_6W(res, fn, a1,a2,a3,a4,a5,a6); \ 2402b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_ENABLE_ERROR_REPORTING; \ 2403ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return res; \ 2404ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 2405ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 2406ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown#define DEFAULT_WRAPPER_W_7W(basename) \ 2407ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown UWord WRAPPER_FOR(PMPI_##basename) \ 2408ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown ( UWord a1, UWord a2, UWord a3, UWord a4, UWord a5, \ 2409ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown UWord a6, UWord a7 ) \ 2410ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown { \ 2411ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown DEFAULT_WRAPPER_PREAMBLE(basename) \ 2412b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_DISABLE_ERROR_REPORTING; \ 2413ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown CALL_FN_W_7W(res, fn, a1,a2,a3,a4,a5,a6,a7); \ 2414b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_ENABLE_ERROR_REPORTING; \ 2415ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return res; \ 2416ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 2417ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 2418ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown#define DEFAULT_WRAPPER_W_8W(basename) \ 2419ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown UWord WRAPPER_FOR(PMPI_##basename) \ 2420ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown ( UWord a1, UWord a2, UWord a3, UWord a4, UWord a5, \ 2421ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown UWord a6, UWord a7, UWord a8 ) \ 2422ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown { \ 2423ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown DEFAULT_WRAPPER_PREAMBLE(basename) \ 2424b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_DISABLE_ERROR_REPORTING; \ 2425ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown CALL_FN_W_8W(res, fn, a1,a2,a3,a4,a5,a6,a7,a8); \ 2426b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_ENABLE_ERROR_REPORTING; \ 2427ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return res; \ 2428ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 2429ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 2430ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown#define DEFAULT_WRAPPER_W_9W(basename) \ 2431ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown UWord WRAPPER_FOR(PMPI_##basename) \ 2432ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown ( UWord a1, UWord a2, UWord a3, UWord a4, UWord a5, \ 2433ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown UWord a6, UWord a7, UWord a8, UWord a9 ) \ 2434ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown { \ 2435ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown DEFAULT_WRAPPER_PREAMBLE(basename) \ 2436b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_DISABLE_ERROR_REPORTING; \ 2437ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown CALL_FN_W_9W(res, fn, a1,a2,a3,a4,a5,a6,a7,a8,a9); \ 2438b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_ENABLE_ERROR_REPORTING; \ 2439ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return res; \ 2440ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 2441ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 2442ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown#define DEFAULT_WRAPPER_W_10W(basename) \ 2443ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown UWord WRAPPER_FOR(PMPI_##basename) \ 2444ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown ( UWord a1, UWord a2, UWord a3, UWord a4, UWord a5, \ 2445ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown UWord a6, UWord a7, UWord a8, UWord a9, UWord a10 ) \ 2446ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown { \ 2447ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown DEFAULT_WRAPPER_PREAMBLE(basename) \ 2448b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_DISABLE_ERROR_REPORTING; \ 2449ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown CALL_FN_W_10W(res, fn, a1,a2,a3,a4,a5,a6,a7,a8,a9,a10); \ 2450b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_ENABLE_ERROR_REPORTING; \ 2451ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return res; \ 2452ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 2453ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 2454ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown#define DEFAULT_WRAPPER_W_12W(basename) \ 2455ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown UWord WRAPPER_FOR(PMPI_##basename) \ 2456ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown ( UWord a1, UWord a2, UWord a3, UWord a4, UWord a5, \ 2457ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown UWord a6, UWord a7, UWord a8, UWord a9, UWord a10, \ 2458ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown UWord a11, UWord a12 ) \ 2459ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown { \ 2460ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown DEFAULT_WRAPPER_PREAMBLE(basename) \ 2461b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_DISABLE_ERROR_REPORTING; \ 2462ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown CALL_FN_W_12W(res, fn, a1,a2,a3,a4,a5,a6, \ 2463ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown a7,a8,a9,a10,a11,a12); \ 2464b32f58018498ea2225959b0ba11c18f0c433deefEvgeniy Stepanov if (cONFIG_DER) VALGRIND_ENABLE_ERROR_REPORTING; \ 2465ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown return res; \ 2466ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown } 2467ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 2468ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 2469ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* Canned summary of MPI-1.1/MPI-2 entry points, as derived from mpi.h 2470ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown from Open MPI svn rev 9191 (somewhere between Open MPI versions 2471ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 1.0.1 and 1.1.0). */ 2472ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 2473ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* If a function is commented out in this list, it's because it has a 2474ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown proper wrapper written elsewhere (above here). */ 2475ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 2476ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_2W(Abort) 2477ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_9W(Accumulate) 2478ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_1W(Add_error_class) 2479ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_2W(Add_error_code) 2480ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_2W(Add_error_string) 2481ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* DEFAULT_WRAPPER_W_2W(Address) */ 2482ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_7W(Allgather) 2483ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_8W(Allgatherv) 2484ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_3W(Alloc_mem) 2485ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* DEFAULT_WRAPPER_W_6W(Allreduce) */ 2486ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* DEFAULT_WRAPPER_W_7W(Alltoall) */ 2487ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_9W(Alltoallv) 2488ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_9W(Alltoallw) 2489ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_2W(Attr_delete) 2490ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_4W(Attr_get) 2491ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_3W(Attr_put) 2492ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_1W(Barrier) 2493ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* DEFAULT_WRAPPER_W_5W(Bcast) */ 2494ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* DEFAULT_WRAPPER_W_6W(Bsend) */ 2495ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_7W(Bsend_init) 2496ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_2W(Buffer_attach) 2497ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_2W(Buffer_detach) 2498ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* DEFAULT_WRAPPER_W_1W(Cancel) */ 2499ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_4W(Cart_coords) 2500ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_6W(Cart_create) 2501ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_5W(Cart_get) 2502ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_5W(Cart_map) 2503ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_3W(Cart_rank) 2504ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_5W(Cart_shift) 2505ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_3W(Cart_sub) 2506ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_2W(Cartdim_get) 2507ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_1W(Close_port) 2508ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_5W(Comm_accept) 2509ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_1W(Comm_c2f) 2510ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_2W(Comm_call_errhandler) 2511ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_3W(Comm_compare) 2512ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_5W(Comm_connect) 2513ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_2W(Comm_create_errhandler) 2514ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_4W(Comm_create_keyval) 2515ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* DEFAULT_WRAPPER_W_3W(Comm_create) */ 2516ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_2W(Comm_delete_attr) 2517ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_1W(Comm_disconnect) 2518ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* DEFAULT_WRAPPER_W_2W(Comm_dup) */ 2519ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_1W(Comm_f2c) 2520ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_1W(Comm_free_keyval) 2521ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* DEFAULT_WRAPPER_W_1W(Comm_free) */ 2522ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_4W(Comm_get_attr) 2523ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_2W(Comm_get_errhandler) 2524ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_3W(Comm_get_name) 2525ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_1W(Comm_get_parent) 2526ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_2W(Comm_group) 2527ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_2W(Comm_join) 2528ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* DEFAULT_WRAPPER_W_2W(Comm_rank) */ 2529ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_2W(Comm_remote_group) 2530ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_2W(Comm_remote_size) 2531ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_3W(Comm_set_attr) 2532ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_2W(Comm_set_errhandler) 2533ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_2W(Comm_set_name) 2534ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* DEFAULT_WRAPPER_W_2W(Comm_size) */ 2535ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_8W(Comm_spawn) 2536ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_9W(Comm_spawn_multiple) 2537ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_4W(Comm_split) 2538ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_2W(Comm_test_inter) 2539ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_3W(Dims_create) 2540ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_1W(Errhandler_c2f) 2541ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_2W(Errhandler_create) 2542ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_1W(Errhandler_f2c) 2543ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_1W(Errhandler_free) 2544ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_2W(Errhandler_get) 2545ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_2W(Errhandler_set) 2546ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_2W(Error_class) 2547ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* DEFAULT_WRAPPER_W_3W(Error_string) */ 2548ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_6W(Exscan) 2549ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_1W(File_c2f) 2550ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_1W(File_f2c) 2551ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_2W(File_call_errhandler) 2552ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_2W(File_create_errhandler) 2553ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_2W(File_set_errhandler) 2554ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_2W(File_get_errhandler) 2555ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_5W(File_open) 2556ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_1W(File_close) 2557ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_2W(File_delete) 2558ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_2W(File_set_size) 2559ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_2W(File_preallocate) 2560ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_2W(File_get_size) 2561ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_2W(File_get_group) 2562ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_2W(File_get_amode) 2563ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_2W(File_set_info) 2564ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_2W(File_get_info) 2565ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_6W(File_set_view) 2566ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_5W(File_get_view) 2567ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_6W(File_read_at) 2568ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_6W(File_read_at_all) 2569ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_6W(File_write_at) 2570ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_6W(File_write_at_all) 2571ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_6W(File_iread_at) 2572ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_6W(File_iwrite_at) 2573ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_5W(File_read) 2574ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_5W(File_read_all) 2575ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_5W(File_write) 2576ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_5W(File_write_all) 2577ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_5W(File_iread) 2578ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_5W(File_iwrite) 2579ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_3W(File_seek) 2580ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_2W(File_get_position) 2581ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_3W(File_get_byte_offset) 2582ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_5W(File_read_shared) 2583ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_5W(File_write_shared) 2584ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_5W(File_iread_shared) 2585ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_5W(File_iwrite_shared) 2586ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_5W(File_read_ordered) 2587ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_5W(File_write_ordered) 2588ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_3W(File_seek_shared) 2589ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_2W(File_get_position_shared) 2590ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_5W(File_read_at_all_begin) 2591ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_3W(File_read_at_all_end) 2592ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_5W(File_write_at_all_begin) 2593ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_3W(File_write_at_all_end) 2594ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_4W(File_read_all_begin) 2595ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_3W(File_read_all_end) 2596ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_4W(File_write_all_begin) 2597ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_3W(File_write_all_end) 2598ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_4W(File_read_ordered_begin) 2599ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_3W(File_read_ordered_end) 2600ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_4W(File_write_ordered_begin) 2601ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_3W(File_write_ordered_end) 2602ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_3W(File_get_type_extent) 2603ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_2W(File_set_atomicity) 2604ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_2W(File_get_atomicity) 2605ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_1W(File_sync) 2606ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* DEFAULT_WRAPPER_W_0W(Finalize) */ 2607ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_1W(Finalized) 2608ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_1W(Free_mem) 2609ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* DEFAULT_WRAPPER_W_8W(Gather) */ 2610ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_9W(Gatherv) 2611ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_2W(Get_address) 2612ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* DEFAULT_WRAPPER_W_3W(Get_count) */ 2613ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_3W(Get_elements) 2614ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_8W(Get) 2615ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_2W(Get_processor_name) 2616ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_2W(Get_version) 2617ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_6W(Graph_create) 2618ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_5W(Graph_get) 2619ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_5W(Graph_map) 2620ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_3W(Graph_neighbors_count) 2621ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_4W(Graph_neighbors) 2622ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_3W(Graphdims_get) 2623ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_1W(Grequest_complete) 2624ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_5W(Grequest_start) 2625ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_1W(Group_c2f) 2626ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_3W(Group_compare) 2627ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_3W(Group_difference) 2628ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_4W(Group_excl) 2629ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_1W(Group_f2c) 2630ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_1W(Group_free) 2631ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_4W(Group_incl) 2632ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_3W(Group_intersection) 2633ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_4W(Group_range_excl) 2634ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_4W(Group_range_incl) 2635ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_2W(Group_rank) 2636ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_2W(Group_size) 2637ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_5W(Group_translate_ranks) 2638ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_3W(Group_union) 2639ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* DEFAULT_WRAPPER_W_7W(Ibsend) */ 2640ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_1W(Info_c2f) 2641ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_1W(Info_create) 2642ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_2W(Info_delete) 2643ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_2W(Info_dup) 2644ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_1W(Info_f2c) 2645ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_1W(Info_free) 2646ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_5W(Info_get) 2647ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_2W(Info_get_nkeys) 2648ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_3W(Info_get_nthkey) 2649ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_4W(Info_get_valuelen) 2650ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_3W(Info_set) 2651ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* DEFAULT_WRAPPER_W_2W(Init) */ 2652ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* DEFAULT_WRAPPER_W_1W(Initialized) */ 2653ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_4W(Init_thread) 2654ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_6W(Intercomm_create) 2655ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_3W(Intercomm_merge) 2656ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* DEFAULT_WRAPPER_W_5W(Iprobe) */ 2657ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* DEFAULT_WRAPPER_W_7W(Irecv) */ 2658ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* DEFAULT_WRAPPER_W_7W(Irsend) */ 2659ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* DEFAULT_WRAPPER_W_7W(Isend) */ 2660ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* DEFAULT_WRAPPER_W_7W(Issend) */ 2661ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_1W(Is_thread_main) 2662ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_4W(Keyval_create) 2663ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_1W(Keyval_free) 2664ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_3W(Lookup_name) 2665ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_1W(Op_c2f) 2666ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* DEFAULT_WRAPPER_W_3W(Op_create) */ 2667ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_2W(Open_port) 2668ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_1W(Op_f2c) 2669ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_1W(Op_free) 2670ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_7W(Pack_external) 2671ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_4W(Pack_external_size) 2672ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* DEFAULT_WRAPPER_W_7W(Pack) */ 2673ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_4W(Pack_size) 2674ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* int MPI_Pcontrol(const int level, ...) */ 2675ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* DEFAULT_WRAPPER_W_4W(Probe) */ 2676ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_3W(Publish_name) 2677ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_8W(Put) 2678ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_1W(Query_thread) 2679ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_7W(Recv_init) 2680ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* DEFAULT_WRAPPER_W_7W(Recv) */ 2681ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* DEFAULT_WRAPPER_W_7W(Reduce) */ 2682ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_6W(Reduce_scatter) 2683ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_5W(Register_datarep) 2684ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_1W(Request_c2f) 2685ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_1W(Request_f2c) 2686ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_1W(Request_free) 2687ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_3W(Request_get_status) 2688ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* DEFAULT_WRAPPER_W_6W(Rsend) */ 2689ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_7W(Rsend_init) 2690ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_6W(Scan) 2691ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* DEFAULT_WRAPPER_W_8W(Scatter) */ 2692ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_9W(Scatterv) 2693ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_7W(Send_init) 2694ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* DEFAULT_WRAPPER_W_6W(Send) */ 2695ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* DEFAULT_WRAPPER_W_12W(Sendrecv) */ 2696ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_9W(Sendrecv_replace) 2697ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_7W(Ssend_init) 2698ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* DEFAULT_WRAPPER_W_6W(Ssend) */ 2699ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_1W(Start) 2700ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_2W(Startall) 2701ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_2W(Status_c2f) 2702ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_2W(Status_f2c) 2703ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_2W(Status_set_cancelled) 2704ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_3W(Status_set_elements) 2705ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* DEFAULT_WRAPPER_W_4W(Testall) */ 2706ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_5W(Testany) 2707ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* DEFAULT_WRAPPER_W_3W(Test) */ 2708ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_2W(Test_cancelled) 2709ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_5W(Testsome) 2710ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_2W(Topo_test) 2711ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_1W(Type_c2f) 2712ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* DEFAULT_WRAPPER_W_1W(Type_commit) */ 2713ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_3W(Type_contiguous) 2714ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_10W(Type_create_darray) 2715ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_3W(Type_create_f90_complex) 2716ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_2W(Type_create_f90_integer) 2717ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_3W(Type_create_f90_real) 2718ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_5W(Type_create_hindexed) 2719ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_5W(Type_create_hvector) 2720ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_4W(Type_create_keyval) 2721ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_5W(Type_create_indexed_block) 2722ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_5W(Type_create_struct) 2723ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_7W(Type_create_subarray) 2724ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_4W(Type_create_resized) 2725ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_2W(Type_delete_attr) 2726ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_2W(Type_dup) 2727ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* DEFAULT_WRAPPER_W_2W(Type_extent) */ 2728ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* DEFAULT_WRAPPER_W_1W(Type_free) */ 2729ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_1W(Type_free_keyval) 2730ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_1W(Type_f2c) 2731ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_4W(Type_get_attr) 2732ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* DEFAULT_WRAPPER_W_7W(Type_get_contents) */ 2733ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* DEFAULT_WRAPPER_W_5W(Type_get_envelope) */ 2734ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_3W(Type_get_extent) 2735ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_3W(Type_get_name) 2736ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_3W(Type_get_true_extent) 2737ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_5W(Type_hindexed) 2738ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_5W(Type_hvector) 2739ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_5W(Type_indexed) 2740ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_2W(Type_lb) 2741ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_3W(Type_match_size) 2742ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_3W(Type_set_attr) 2743ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_2W(Type_set_name) 2744ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_2W(Type_size) 2745ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_5W(Type_struct) 2746ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_2W(Type_ub) 2747ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_5W(Type_vector) 2748ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* DEFAULT_WRAPPER_W_7W(Unpack) */ 2749ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_3W(Unpublish_name) 2750ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_7W(Unpack_external) 2751ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* DEFAULT_WRAPPER_W_3W(Waitall) */ 2752ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* DEFAULT_WRAPPER_W_4W(Waitany) */ 2753ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* DEFAULT_WRAPPER_W_2W(Wait) */ 2754ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_5W(Waitsome) 2755ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_1W(Win_c2f) 2756ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_2W(Win_call_errhandler) 2757ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_1W(Win_complete) 2758ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_6W(Win_create) 2759ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_2W(Win_create_errhandler) 2760ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_4W(Win_create_keyval) 2761ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_2W(Win_delete_attr) 2762ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_1W(Win_f2c) 2763ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_2W(Win_fence) 2764ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_1W(Win_free) 2765ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_1W(Win_free_keyval) 2766ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_4W(Win_get_attr) 2767ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_2W(Win_get_errhandler) 2768ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_2W(Win_get_group) 2769ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_3W(Win_get_name) 2770ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_4W(Win_lock) 2771ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_3W(Win_post) 2772ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_3W(Win_set_attr) 2773ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_2W(Win_set_errhandler) 2774ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_2W(Win_set_name) 2775ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_3W(Win_start) 2776ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_2W(Win_test) 2777ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_2W(Win_unlock) 2778ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff BrownDEFAULT_WRAPPER_W_1W(Win_wait) 2779ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* double MPI_Wtick(void) */ 2780ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/* double MPI_Wtime(void) */ 2781ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 2782ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 2783ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*------------------------------------------------------------*/ 2784ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*--- ---*/ 2785ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*--- ---*/ 2786ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*--- ---*/ 2787ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*------------------------------------------------------------*/ 2788ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown 2789ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*---------------------------------------------------------------*/ 2790ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*--- end mpiwrap.c ---*/ 2791ed07e00d438c74b7a23c01bfffde77e3968305e4Jeff Brown/*---------------------------------------------------------------*/ 2792