-: 0:Source:../../include/mpicxx.h
-: 0:Graph:initcxx.gcno
-: 0:Data:initcxx.gcda
-: 0:Runs:509
-: 0:Programs:136
-: 1:/* -*- Mode: C++; c-basic-offset:4 ; -*- */
-: 2:/*
-: 3: * (C) 2001 by Argonne National Laboratory.
-: 4: * See COPYRIGHT in top-level directory.
-: 5: *
-: 6: * This file is automatically generated by buildiface -nosep
-: 7: * DO NOT EDIT
-: 8: */
-: 9:/* style: c++ header */
-: 10:
-: 11:#ifdef MPI
-: 12:#error "You cannot define MPI; that name is reserved for the MPI namespace"
-: 13:#endif
-: 14:
-: 15:// Check for incompatible GCC versions
-: 16:// GCC (specifically) g++ changed the calling convention
-: 17:// between 3.2.3 and 3.4.3 (!!) Normally such changes
-: 18:// should only occur at major releases (e.g., version 3 to 4)
-: 19:#ifdef __GNUC__
-: 20:# if __GNUC__ >= 4
-: 21:# if __GNUC_MINOR__ > 2 && 2 == 2
-: 22:# error 'Please use the same version of GCC and g++ for compiling MPICH2 and user MPI programs'
-: 23:# endif
-: 24:# endif
-: 25:#endif
-: 26:// There is a name conflict between stdio.h and iostream (or iostream.h)
-: 27:// and the MPI C++ binding with respect to the names SEEK_SET, SEEK_CUR,
-: 28:// and SEEK_END. MPI wants these in the MPI namespace, but stdio.h,
-: 29:// iostream, or iostream.h will #define these to integer values.
-: 30:// #undef'ing these can cause obscure problems.
-: 31:#ifndef MPICH_IGNORE_CXX_SEEK
-: 32:
-: 33:// MPICH_DONT_INCLUDE_STDIO_H is another escape hatch for us, just like
-: 34:// MPICH_IGNORE_CXX_SEEK. If we encounter a wacky environment or user in the
-: 35:// wild that does not want our workaround and/or the stdio.h header, then we can
-: 36:// offer them a way out.
-: 37:#ifndef MPICH_DONT_INCLUDE_STDIO_H
-: 38:// ensure that we have SEEK_* defined
-: 39:# include <stdio.h>
-: 40:#endif
-: 41:
-: 42:enum MPIR_Dummy_seek_type {
-: 43: MPIR_DUMMY_SEEK_COMMA_VAL = -1 // permits cleaner comma logic
-: 44:#ifdef SEEK_SET
-: 45: , MPIR_SEEK_SET = SEEK_SET
-: 46:# undef SEEK_SET
-: 47: , SEEK_SET = MPIR_SEEK_SET
-: 48:#endif
-: 49:#ifdef SEEK_CUR
-: 50: , MPIR_SEEK_CUR = SEEK_CUR
-: 51:# undef SEEK_CUR
-: 52: , SEEK_CUR = MPIR_SEEK_CUR
-: 53:#endif
-: 54:#ifdef SEEK_END
-: 55: , MPIR_SEEK_END = SEEK_END
-: 56:# undef SEEK_END
-: 57: , SEEK_END = MPIR_SEEK_END
-: 58:#endif
-: 59:#ifdef LOCK_SHARED
-: 60: , MPIR_LOCK_SHARED = LOCK_SHARED
-: 61:# undef LOCK_SHARED
-: 62: , LOCK_SHARED = MPIR_LOCK_SHARED
-: 63:#endif
-: 64:};
-: 65:
-: 66:#endif // MPICH_IGNORE_CXX_SEEK
-: 67:namespace MPI {
-: 68:#if 1
-: 69:#define MPIX_CALL( fnc ) \
-: 70:{int err; err = fnc ; if (err) throw Exception(err);}
-: 71:#else
-: 72:#define MPIX_CALL( fnc ) (void)fnc
-: 73:#endif
-: 74:
-: 75:// Typedefs for basic int types
-: 76:typedef MPI_Offset Offset;
-: 77:typedef MPI_Aint Aint;
-: 78:typedef MPI_Fint Fint;
-: 79:
-: 80:// Special internal routine
-: 81:void MPIR_CXX_InitDatatypeNames( void );
-: 82:
-: 83:// Forward class declarations
-: 84:class Comm;
-: 85:class Nullcomm;
-: 86:class Intercomm;
-: 87:class Intracomm;
-: 88:class Cartcomm;
-: 89:class Graphcomm;
-: 90:
-: 91:// base (classless) routines
-: 92:extern int Detach_buffer( void *&v1 ) ;
-: 93:extern bool Is_initialized( void ) ;
-: 94:extern void Get_processor_name( char * v1, int &v2 ) ;
-: 95:extern void Get_error_string( int v1, char * v2, int &v3 ) ;
-: 96:extern void Compute_dims( int v1, int v2, int * v3 ) ;
-: 97:extern void Get_version( int &v1, int &v2 ) ;
-: 98:extern void Finalize( void ) ;
-: 99:extern void Pcontrol( const int v1, ... ) ;
-: 100:extern void Attach_buffer( void* v1, int v2 ) ;
-: 101:extern int Get_error_class( int v1 ) ;
-: 102:
-: 103:class Exception {
-: 104:
-: 105: protected:
-: 106: int the_real_exception;
-: 107:
-: 108: public:
-: 109: // new/delete
-: 110:
2: 111: inline Exception(int obj) : the_real_exception(obj) {}
-: 112: inline Exception(void) : the_real_exception(0) {}
-: 113:
|
#####: 114: virtual ~Exception() {}
-: 115: // copy/assignment
-: 116:
-: 117: Exception(const Exception &obj) : the_real_exception(obj.the_real_exception){}
-: 118:
-: 119: Exception& operator=(const Exception &obj) {
-: 120: the_real_exception = obj.the_real_exception; return *this; }
-: 121:
-: 122: // logical
-: 123: bool operator== (const Exception &obj) {
-: 124: return (the_real_exception == obj.the_real_exception); }
-: 125: bool operator!= (const Exception &obj) {
-: 126: return (the_real_exception != obj.the_real_exception); }
-: 127: // C/C++ cast and assignment
-: 128: inline operator int*() { return &the_real_exception; }
-: 129: inline operator int() const { return the_real_exception; }
-: 130: Exception& operator=(const int& obj) {
-: 131: the_real_exception = obj; return *this; }
-: 132:
-: 133: protected:
-: 134: char the_error_message[MPI_MAX_ERROR_STRING];
-: 135: public:
-: 136: int Get_error_code(void) { return the_real_exception; }
-: 137: int Get_error_class(void) { return MPI::Get_error_class(the_real_exception); }
-: 138: const char *Get_error_string(void)
-: 139: {
-: 140: int len;
-: 141: MPI_Error_string(the_real_exception, the_error_message, &len);
-: 142: return the_error_message;
-: 143: }
-: 144:};
-: 145:
-: 146:class Datatype {
-: 147: friend class Comm;
-: 148: friend class Status;
-: 149: friend class Intracomm;
-: 150: friend class Intercomm;
-: 151: friend class Win;
-: 152: friend class File;
-: 153: friend class Op;
-: 154:
-: 155: protected:
-: 156: MPI_Datatype the_real_datatype;
-: 157:
-: 158: public:
-: 159: // new/delete
-: 160:
|
26920: 161: inline Datatype(MPI_Datatype obj) : the_real_datatype(obj) {}
509: 162: inline Datatype(void) : the_real_datatype(MPI_DATATYPE_NULL) {}
-: 163:
27429: 164: virtual ~Datatype() {}
-: 165: // copy/assignment
-: 166:
-: 167: Datatype(const Datatype &obj) : the_real_datatype(obj.the_real_datatype){}
-: 168:
-: 169: Datatype& operator=(const Datatype &obj) {
-: 170: the_real_datatype = obj.the_real_datatype; return *this; }
-: 171:
-: 172: // logical
-: 173: bool operator== (const Datatype &obj) {
-: 174: return (the_real_datatype == obj.the_real_datatype); }
-: 175: bool operator!= (const Datatype &obj) {
-: 176: return (the_real_datatype != obj.the_real_datatype); }
-: 177: // C/C++ cast and assignment
-: 178: inline operator MPI_Datatype*() { return &the_real_datatype; }
8: 179: inline operator MPI_Datatype() const { return the_real_datatype; }
-: 180: Datatype& operator=(const MPI_Datatype& obj) {
-: 181: the_real_datatype = obj; return *this; }
|
#####: 182: virtual void Commit( void )
-: 183: {
#####: 184: MPIX_CALL( MPI_Type_commit( (MPI_Datatype *) &the_real_datatype ));
#####: 185: }
#####: 186: virtual void Free( void )
-: 187: {
#####: 188: MPIX_CALL( MPI_Type_free( (MPI_Datatype *) &the_real_datatype ));
#####: 189: }
#####: 190: virtual Datatype Create_indexed( int v1, const int * v2, const int * v3 ) const
-: 191: {
#####: 192: Datatype v5;
#####: 193: MPIX_CALL( MPI_Type_indexed( v1, (int *)v2, (int *)v3, (MPI_Datatype) the_real_datatype, &(v5.the_real_datatype) ));
#####: 194: return v5;
-: 195: }
#####: 196: virtual Datatype Create_contiguous( int v1 ) const
-: 197: {
#####: 198: Datatype v3;
#####: 199: MPIX_CALL( MPI_Type_contiguous( v1, (MPI_Datatype) the_real_datatype, &(v3.the_real_datatype) ));
#####: 200: return v3;
-: 201: }
#####: 202: virtual Datatype Create_vector( int v1, int v2, int v3 ) const
-: 203: {
#####: 204: Datatype v5;
#####: 205: MPIX_CALL( MPI_Type_vector( v1, v2, v3, (MPI_Datatype) the_real_datatype, &(v5.the_real_datatype) ));
#####: 206: return v5;
-: 207: }
-: 208: static Datatype Create_struct( int v1, int v2[], MPI_Aint v3[], const Datatype v4[] )
-: 209: {
-: 210: Datatype v5;
-: 211: MPI_Datatype *l4 = new MPI_Datatype[v1];
-: 212: {
-: 213: int i4;
-: 214: for (i4=0;i4<v1;i4++) {
-: 215: l4[i4] = v4[i4].the_real_datatype;
-: 216: }
-: 217: }
-: 218: MPIX_CALL( MPI_Type_create_struct( v1, (int *)v2, (MPI_Aint *)v3, l4, &(v5.the_real_datatype) ));
-: 219: delete[] l4;
-: 220: return v5;
-: 221: }
-: 222: virtual int Pack_size( int v1, const Comm &v3 ) const;
-: 223: virtual void Pack( const void* v1, int v2, void * v4, int v5, int &v6, const Comm &v7 ) const;
#####: 224: virtual int Get_size( void ) const
-: 225: {
-: 226: int v2;
#####: 227: MPIX_CALL( MPI_Type_size( (MPI_Datatype) the_real_datatype, &v2 ));
#####: 228: return v2;
-: 229: }
#####: 230: virtual void Get_envelope( int &v2, int &v3, int &v4, int &v5 ) const
-: 231: {
#####: 232: MPIX_CALL( MPI_Type_get_envelope( (MPI_Datatype) the_real_datatype, &v2, &v3, &v4, &v5 ));
#####: 233: }
#####: 234: virtual Datatype Create_hvector( int v1, int v2, Aint v3 ) const
-: 235: {
#####: 236: Datatype v5;
#####: 237: MPIX_CALL( MPI_Type_create_hvector( v1, v2, v3, (MPI_Datatype) the_real_datatype, &(v5.the_real_datatype) ));
#####: 238: return v5;
-: 239: }
-: 240: static Datatype Match_size( int v1, int v2 )
-: 241: {
-: 242: Datatype v3;
-: 243: MPIX_CALL( MPI_Type_match_size( v1, v2, &(v3.the_real_datatype) ));
-: 244: return v3;
-: 245: }
#####: 246: virtual Datatype Create_resized( const Aint v2, const Aint v3 ) const
-: 247: {
#####: 248: Datatype v4;
#####: 249: MPIX_CALL( MPI_Type_create_resized( (MPI_Datatype) the_real_datatype, (MPI_Aint)v2, (MPI_Aint)v3, &(v4.the_real_datatype) ));
#####: 250: return v4;
-: 251: }
#####: 252: virtual Datatype Create_indexed_block( int v1, int v2, const int v3[] ) const
-: 253: {
#####: 254: Datatype v5;
#####: 255: MPIX_CALL( MPI_Type_create_indexed_block( v1, v2, (int *)v3, (MPI_Datatype) the_real_datatype, &(v5.the_real_datatype) ));
#####: 256: return v5;
-: 257: }
#####: 258: virtual Aint Pack_external_size( char * v1, const int v2 ) const
-: 259: {
-: 260: MPI_Aint v4;
#####: 261: MPIX_CALL( MPI_Pack_external_size( v1, (int)v2, (MPI_Datatype) the_real_datatype, &v4 ));
#####: 262: return v4;
-: 263: }
-: 264: Datatype Dup( void ) const
-: 265: {
-: 266: Datatype v2;
-: 267: MPIX_CALL( MPI_Type_dup( (MPI_Datatype) the_real_datatype, &(v2.the_real_datatype) ));
-: 268: return v2;
-: 269: }
#####: 270: virtual Datatype Create_hindexed( int v1, const int v2[], const Aint v3[] ) const
-: 271: {
#####: 272: Datatype v5;
#####: 273: MPIX_CALL( MPI_Type_create_hindexed( v1, (int *)v2, (MPI_Aint *)v3, (MPI_Datatype) the_real_datatype, &(v5.the_real_datatype) ));
#####: 274: return v5;
-: 275: }
#####: 276: virtual bool Get_attr( int v2, void * v3 ) const
-: 277: {
-: 278: int v4;
#####: 279: MPIX_CALL( MPI_Type_get_attr( (MPI_Datatype) the_real_datatype, v2, v3, &v4 ));
#####: 280: return v4!= 0;
-: 281: }
#####: 282: virtual void Get_true_extent( Aint & v2, Aint & v3 ) const
-: 283: {
#####: 284: MPIX_CALL( MPI_Type_get_true_extent( (MPI_Datatype) the_real_datatype, &v2, &v3 ));
#####: 285: }
#####: 286: virtual Datatype Create_darray( int v1, int v2, int v3, const int v4[], const int v5[], const int v6[], const int v7[], int v8 ) const
-: 287: {
#####: 288: Datatype v10;
#####: 289: MPIX_CALL( MPI_Type_create_darray( v1, v2, v3, (int *)v4, (int *)v5, (int *)v6, (int *)v7, v8, (MPI_Datatype) the_real_datatype, &(v10.the_real_datatype) ));
#####: 290: return v10;
-: 291: }
-: 292: static Datatype Create_f90_real( int v1, int v2 )
-: 293: {
-: 294: Datatype v3;
-: 295: MPIX_CALL( MPI_Type_create_f90_real( v1, v2, &(v3.the_real_datatype) ));
-: 296: return v3;
-: 297: }
#####: 298: virtual void Get_contents( int v2, int v3, int v4, int v5[], MPI_Aint v6[], Datatype v7[] ) const
-: 299: {
#####: 300: MPI_Datatype *l7 = new MPI_Datatype[v4];
#####: 301: MPIX_CALL( MPI_Type_get_contents( (MPI_Datatype) the_real_datatype, v2, v3, v4, v5, v6, l7 ));
-: 302: {
-: 303: int i7;
#####: 304: for (i7=0;i7<v4;i7++) {
#####: 305: v7[i7].the_real_datatype = l7[i7];
-: 306: }
#####: 307: delete[] l7;
-: 308: }
#####: 309: }
#####: 310: virtual void Set_attr( int v2, const void * v3 )
-: 311: {
#####: 312: MPIX_CALL( MPI_Type_set_attr( (MPI_Datatype) the_real_datatype, v2, (void *)v3 ));
#####: 313: }
#####: 314: virtual void Set_name( const char * v2 )
-: 315: {
#####: 316: MPIX_CALL( MPI_Type_set_name( (MPI_Datatype) the_real_datatype, (char *)v2 ));
#####: 317: }
-: 318: static Datatype Create_f90_complex( int v1, int v2 )
-: 319: {
-: 320: Datatype v3;
-: 321: MPIX_CALL( MPI_Type_create_f90_complex( v1, v2, &(v3.the_real_datatype) ));
-: 322: return v3;
-: 323: }
#####: 324: virtual Datatype Create_subarray( int v1, int v2[], const int v3[], const int v4[], const int v5 ) const
-: 325: {
#####: 326: Datatype v7;
#####: 327: MPIX_CALL( MPI_Type_create_subarray( v1, v2, (int *)v3, (int *)v4, (int)v5, (MPI_Datatype) the_real_datatype, &(v7.the_real_datatype) ));
#####: 328: return v7;
-: 329: }
#####: 330: virtual void Unpack_external( char * v1, const void * v2, const Aint v3, Aint & v4, void * v5, int v6 ) const
-: 331: {
#####: 332: MPIX_CALL( MPI_Unpack_external( v1, (void *)v2, (MPI_Aint)v3, &v4, v5, v6, (MPI_Datatype) the_real_datatype ));
#####: 333: }
-: 334: static void Free_keyval( int &v1 )
-: 335: {
-: 336: MPIX_CALL( MPI_Type_free_keyval( &v1 ));
-: 337: }
-: 338: static Datatype Create_struct( int v1, const int v2[], const Aint v3[], const Datatype v4[] )
-: 339: {
-: 340: Datatype v5;
-: 341: MPI_Datatype *l4 = new MPI_Datatype[v1];
-: 342: {
-: 343: int i4;
-: 344: for (i4=0;i4<v1;i4++) {
-: 345: l4[i4] = v4[i4].the_real_datatype;
-: 346: }
-: 347: }
-: 348: MPIX_CALL( MPI_Type_create_struct( v1, (int *)v2, (MPI_Aint *)v3, l4, &(v5.the_real_datatype) ));
-: 349: delete[] l4;
-: 350: return v5;
-: 351: }
-: 352: static Datatype Create_f90_integer( int v1 )
-: 353: {
-: 354: Datatype v2;
-: 355: MPIX_CALL( MPI_Type_create_f90_integer( v1, &(v2.the_real_datatype) ));
-: 356: return v2;
-: 357: }
#####: 358: virtual void Pack_external( char * v1, const void * v2, const int v3, void * v5, Aint v6, Aint & v7 ) const
-: 359: {
#####: 360: MPIX_CALL( MPI_Pack_external( v1, (void *)v2, (int)v3, (MPI_Datatype) the_real_datatype, v5, v6, &v7 ));
#####: 361: }
#####: 362: virtual void Get_extent( Aint & v2, Aint & v3 ) const
-: 363: {
#####: 364: MPIX_CALL( MPI_Type_get_extent( (MPI_Datatype) the_real_datatype, &v2, &v3 ));
#####: 365: }
#####: 366: virtual void Delete_attr( int v2 )
-: 367: {
#####: 368: MPIX_CALL( MPI_Type_delete_attr( (MPI_Datatype) the_real_datatype, v2 ));
#####: 369: }
#####: 370: virtual void Get_name( char * v2, int &v3 ) const
-: 371: {
#####: 372: MPIR_CXX_InitDatatypeNames();
#####: 373: MPIX_CALL( MPI_Type_get_name( (MPI_Datatype) the_real_datatype, v2, &v3 ));
#####: 374: }
-: 375:
-: 376: void Unpack( const void *, int, void *, int, int &, const Comm & ) const;
-: 377:
-: 378: typedef int Copy_attr_function(const Datatype& oldtype, int type_keyval, void* extra_state, void* attribute_val_in, void* attribute_val_out, bool& flag);
-: 379: typedef int Delete_attr_function(Datatype& type, int type_keyval, void* attribute_val, void* extra_state);
-: 380:
-: 381: static int Create_keyval( Copy_attr_function *, Delete_attr_function *,
-: 382: void * );
-: 383: // These functions are *not* part of MPI-2 but are provided
-: 384: // because they should have been included
-: 385: static int NULL_COPY_FN( const Datatype &oldtype, int keyval, void *ex,
#####: 386: void *attr_in, void *attr_out, bool &flag ) { flag = 1; return 0;}
-: 387: static int NULL_DELETE_FN( Datatype &type, int keyval, void * attr,
#####: 388: void *ex ) { return 0; }
-: 389: static int DUP_FN( const Datatype &oldtype, int keyval, void *ex,
-: 390: void *attr_in, void *attr_out, bool &flag ) { flag = 1;
-: 391: *(void **)attr_out = attr_in; return 0;}
-: 392:
-: 393:
-: 394:};
-: 395:
-: 396: typedef void User_function(const void *, void*, int, const Datatype&);
-: 397:
-: 398:class Info {
-: 399: friend class File;
-: 400: friend class Win;
-: 401: friend class Comm;
-: 402: friend class Intracomm;
-: 403:
-: 404: protected:
-: 405: MPI_Info the_real_info;
-: 406:
-: 407: public:
-: 408: // new/delete
-: 409:
-: 410: inline Info(MPI_Info obj) : the_real_info(obj) {}
|
509: 411: inline Info(void) : the_real_info(MPI_INFO_NULL) {}
-: 412:
509: 413: virtual ~Info() {}
-: 414: // copy/assignment
-: 415:
-: 416: Info(const Info &obj) : the_real_info(obj.the_real_info){}
-: 417:
-: 418: Info& operator=(const Info &obj) {
-: 419: the_real_info = obj.the_real_info; return *this; }
-: 420:
-: 421: // logical
-: 422: bool operator== (const Info &obj) {
-: 423: return (the_real_info == obj.the_real_info); }
-: 424: bool operator!= (const Info &obj) {
-: 425: return (the_real_info != obj.the_real_info); }
-: 426: // C/C++ cast and assignment
-: 427: inline operator MPI_Info*() { return &the_real_info; }
8: 428: inline operator MPI_Info() const { return the_real_info; }
-: 429: Info& operator=(const MPI_Info& obj) {
-: 430: the_real_info = obj; return *this; }
|
#####: 431: virtual void Delete( const char * v2 )
-: 432: {
#####: 433: MPIX_CALL( MPI_Info_delete( (MPI_Info) the_real_info, (char *)v2 ));
#####: 434: }
#####: 435: virtual void Get_nthkey( int v2, char * v3 ) const
-: 436: {
#####: 437: MPIX_CALL( MPI_Info_get_nthkey( (MPI_Info) the_real_info, v2, v3 ));
#####: 438: }
#####: 439: virtual void Free( void )
-: 440: {
#####: 441: MPIX_CALL( MPI_Info_free( (MPI_Info *) &the_real_info ));
#####: 442: }
-: 443: static Info Create( void )
-: 444: {
-: 445: Info v1;
-: 446: MPIX_CALL( MPI_Info_create( &(v1.the_real_info) ));
-: 447: return v1;
-: 448: }
#####: 449: virtual void Set( const char * v2, const char * v3 )
-: 450: {
#####: 451: MPIX_CALL( MPI_Info_set( (MPI_Info) the_real_info, (char *)v2, (char *)v3 ));
#####: 452: }
-: 453: Info Dup( void ) const
-: 454: {
-: 455: Info v2;
-: 456: MPIX_CALL( MPI_Info_dup( (MPI_Info) the_real_info, &(v2.the_real_info) ));
-: 457: return v2;
-: 458: }
#####: 459: virtual bool Get_valuelen( const char * v2, int &v3 ) const
-: 460: {
-: 461: int v4;
#####: 462: MPIX_CALL( MPI_Info_get_valuelen( (MPI_Info) the_real_info, (char *)v2, &v3, &v4 ));
#####: 463: return v4!= 0;
-: 464: }
#####: 465: virtual bool Get( const char * v2, int v3, char * v4 ) const
-: 466: {
-: 467: int v5;
#####: 468: MPIX_CALL( MPI_Info_get( (MPI_Info) the_real_info, (char *)v2, v3, v4, &v5 ));
#####: 469: return v5!= 0;
-: 470: }
#####: 471: virtual int Get_nkeys( void ) const
-: 472: {
-: 473: int v2;
#####: 474: MPIX_CALL( MPI_Info_get_nkeys( (MPI_Info) the_real_info, &v2 ));
#####: 475: return v2;
-: 476: }
-: 477:};
-: 478:
-: 479:class Status {
-: 480: friend class Comm;
-: 481: friend class File;
-: 482: friend class Request;
-: 483:
-: 484: protected:
-: 485: MPI_Status the_real_status;
-: 486:
-: 487: public:
-: 488: // new/delete
-: 489:
-: 490: inline Status(MPI_Status obj) : the_real_status(obj) {}
#####: 491: inline Status(void) : the_real_status() {}
-: 492:
#####: 493: virtual ~Status() {}
-: 494: // copy/assignment
-: 495:
-: 496: Status(const Status &obj) : the_real_status(obj.the_real_status){}
-: 497:
-: 498: Status& operator=(const Status &obj) {
-: 499: the_real_status = obj.the_real_status; return *this; }
-: 500:
-: 501: // C/C++ cast and assignment
-: 502: inline operator MPI_Status*() { return &the_real_status; }
#####: 503: inline operator MPI_Status() const { return the_real_status; }
-: 504: Status& operator=(const MPI_Status& obj) {
-: 505: the_real_status = obj; return *this; }
#####: 506: virtual bool Is_cancelled( void ) const
-: 507: {
-: 508: int v2;
#####: 509: MPIX_CALL( MPI_Test_cancelled( (MPI_Status *) &the_real_status, &v2 ));
#####: 510: return v2!= 0;
-: 511: }
#####: 512: virtual int Get_elements( const Datatype &v2 ) const
-: 513: {
-: 514: int v3;
#####: 515: MPIX_CALL( MPI_Get_elements( (MPI_Status *) &the_real_status, (MPI_Datatype)(v2.the_real_datatype), &v3 ));
#####: 516: return v3;
-: 517: }
#####: 518: virtual int Get_count( const Datatype &v2 ) const
-: 519: {
-: 520: int v3;
#####: 521: MPIX_CALL( MPI_Get_count( (MPI_Status *) &the_real_status, (MPI_Datatype)(v2.the_real_datatype), &v3 ));
#####: 522: return v3;
-: 523: }
#####: 524: virtual void Set_cancelled( bool v2 )
-: 525: {
-: 526: int l2;
#####: 527: l2 = (v2 == true) ? 1 : 0;
#####: 528: MPIX_CALL( MPI_Status_set_cancelled( (MPI_Status *) &the_real_status, l2 ));
#####: 529: }
#####: 530: virtual void Set_elements( const Datatype &v2, int v3 )
-: 531: {
#####: 532: MPIX_CALL( MPI_Status_set_elements( (MPI_Status *) &the_real_status, (MPI_Datatype)(v2.the_real_datatype), v3 ));
#####: 533: }
-: 534:
-: 535: int Get_source(void) const { return the_real_status.MPI_SOURCE; }
-: 536: int Get_tag(void) const { return the_real_status.MPI_TAG; }
-: 537: int Get_error(void) const { return the_real_status.MPI_ERROR; }
-: 538: void Set_source(int source) { the_real_status.MPI_SOURCE = source; }
-: 539: void Set_tag(int tag) { the_real_status.MPI_TAG = tag; }
-: 540: void Set_error(int error) { the_real_status.MPI_ERROR = error; }
-: 541:};
-: 542:
-: 543:class Group {
-: 544: friend class Comm;
-: 545: friend class Intracomm;
-: 546: friend class Intercomm;
-: 547: friend class Win;
-: 548: friend class File;
-: 549:
-: 550: protected:
-: 551: MPI_Group the_real_group;
-: 552:
-: 553: public:
-: 554: // new/delete
-: 555:
|
509: 556: inline Group(MPI_Group obj) : the_real_group(obj) {}
517: 557: inline Group(void) : the_real_group(MPI_GROUP_NULL) {}
-: 558:
1018: 559: virtual ~Group() {}
-: 560: // copy/assignment
-: 561:
-: 562: Group(const Group &obj) : the_real_group(obj.the_real_group){}
-: 563:
-: 564: Group& operator=(const Group &obj) {
-: 565: the_real_group = obj.the_real_group; return *this; }
-: 566:
-: 567: // logical
-: 568: bool operator== (const Group &obj) {
-: 569: return (the_real_group == obj.the_real_group); }
-: 570: bool operator!= (const Group &obj) {
-: 571: return (the_real_group != obj.the_real_group); }
-: 572: // C/C++ cast and assignment
-: 573: inline operator MPI_Group*() { return &the_real_group; }
-: 574: inline operator MPI_Group() const { return the_real_group; }
-: 575: Group& operator=(const MPI_Group& obj) {
-: 576: the_real_group = obj; return *this; }
|
#####: 577: virtual Group Excl( int v2, const int * v3 ) const
-: 578: {
#####: 579: Group v4;
#####: 580: MPIX_CALL( MPI_Group_excl( (MPI_Group) the_real_group, v2, (int *)v3, &(v4.the_real_group) ));
#####: 581: return v4;
-: 582: }
#####: 583: virtual int Get_rank( void ) const
-: 584: {
-: 585: int v2;
#####: 586: MPIX_CALL( MPI_Group_rank( (MPI_Group) the_real_group, &v2 ));
#####: 587: return v2;
-: 588: }
#####: 589: virtual void Free( void )
-: 590: {
#####: 591: MPIX_CALL( MPI_Group_free( (MPI_Group *) &the_real_group ));
#####: 592: }
-: 593: static Group Union( const Group &v1, const Group &v2 )
-: 594: {
-: 595: Group v3;
-: 596: MPIX_CALL( MPI_Group_union( (MPI_Group)(v1.the_real_group), (MPI_Group)(v2.the_real_group), &(v3.the_real_group) ));
-: 597: return v3;
-: 598: }
-: 599: static Group Intersect( const Group &v1, const Group &v2 )
-: 600: {
-: 601: Group v3;
-: 602: MPIX_CALL( MPI_Group_intersection( (MPI_Group)(v1.the_real_group), (MPI_Group)(v2.the_real_group), &(v3.the_real_group) ));
-: 603: return v3;
-: 604: }
#####: 605: virtual Group Range_excl( int v2, const int v3[][3] ) const
-: 606: {
#####: 607: Group v4;
#####: 608: MPIX_CALL( MPI_Group_range_excl( (MPI_Group) the_real_group, v2, (int (*)[3])v3, &(v4.the_real_group) ));
#####: 609: return v4;
-: 610: }
#####: 611: virtual Group Range_incl( int v2, const int v3[][3] ) const
-: 612: {
#####: 613: Group v4;
#####: 614: MPIX_CALL( MPI_Group_range_incl( (MPI_Group) the_real_group, v2, (int (*)[3])v3, &(v4.the_real_group) ));
#####: 615: return v4;
-: 616: }
-: 617: static Group Difference( const Group &v1, const Group &v2 )
-: 618: {
-: 619: Group v3;
-: 620: MPIX_CALL( MPI_Group_difference( (MPI_Group)(v1.the_real_group), (MPI_Group)(v2.the_real_group), &(v3.the_real_group) ));
-: 621: return v3;
-: 622: }
-: 623: static void Translate_ranks( const Group &v1, int v2, const int * v3, const Group &v4, int * v5 )
-: 624: {
-: 625: MPIX_CALL( MPI_Group_translate_ranks( (MPI_Group)(v1.the_real_group), v2, (int *)v3, (MPI_Group)(v4.the_real_group), v5 ));
-: 626: }
#####: 627: virtual Group Incl( int v2, const int * v3 ) const
-: 628: {
#####: 629: Group v4;
#####: 630: MPIX_CALL( MPI_Group_incl( (MPI_Group) the_real_group, v2, (int *)v3, &(v4.the_real_group) ));
#####: 631: return v4;
-: 632: }
#####: 633: virtual int Get_size( void ) const
-: 634: {
-: 635: int v2;
#####: 636: MPIX_CALL( MPI_Group_size( (MPI_Group) the_real_group, &v2 ));
#####: 637: return v2;
-: 638: }
-: 639: static int Compare( const Group &v1, const Group &v2 )
-: 640: {
-: 641: int v3;
-: 642: MPIX_CALL( MPI_Group_compare( (MPI_Group)(v1.the_real_group), (MPI_Group)(v2.the_real_group), &v3 ));
-: 643: return v3;
-: 644: }
-: 645:};
-: 646:
-: 647:class Op {
-: 648: friend class Intracomm;
-: 649: friend class Intercomm;
-: 650: friend class Win;
-: 651: friend class Comm;
-: 652:
-: 653: protected:
-: 654: MPI_Op the_real_op;
-: 655:
-: 656: public:
-: 657: // new/delete
-: 658:
|
6617: 659: inline Op(MPI_Op obj) : the_real_op(obj) {}
509: 660: inline Op(void) : the_real_op(MPI_OP_NULL) {}
-: 661:
7126: 662: virtual ~Op() {}
-: 663: // copy/assignment
-: 664:
-: 665: Op(const Op &obj) : the_real_op(obj.the_real_op){}
-: 666:
-: 667: Op& operator=(const Op &obj) {
-: 668: the_real_op = obj.the_real_op; return *this; }
-: 669:
-: 670: // logical
-: 671: bool operator== (const Op &obj) {
-: 672: return (the_real_op == obj.the_real_op); }
-: 673: bool operator!= (const Op &obj) {
-: 674: return (the_real_op != obj.the_real_op); }
-: 675: // C/C++ cast and assignment
-: 676: inline operator MPI_Op*() { return &the_real_op; }
-: 677: inline operator MPI_Op() const { return the_real_op; }
-: 678: Op& operator=(const MPI_Op& obj) {
-: 679: the_real_op = obj; return *this; }
|
#####: 680: virtual void Free( void )
-: 681: {
#####: 682: MPIX_CALL( MPI_Op_free( (MPI_Op *) &the_real_op ));
#####: 683: }
#####: 684: virtual bool Is_commutative( void )
-: 685: {
-: 686: int v2;
#####: 687: MPIX_CALL( MPI_Op_commutative( (MPI_Op) the_real_op, &v2 ));
#####: 688: return v2!= 0;
-: 689: }
#####: 690: virtual void Reduce_local( void * v1, void * v2, int v3, Datatype v4 )
-: 691: {
#####: 692: MPIX_CALL( MPI_Reduce_local( v1, v2, v3, (MPI_Datatype)(v4.the_real_datatype), (MPI_Op) the_real_op ));
#####: 693: }
-: 694:
-: 695: void Init( User_function *, bool );
-: 696:};
-: 697:
-: 698:class Errhandler {
-: 699: friend class Comm;
-: 700: friend class File;
-: 701: friend class Win;
-: 702:
-: 703: protected:
-: 704: MPI_Errhandler the_real_errhandler;
-: 705:
-: 706: public:
-: 707: // new/delete
-: 708:
|
1527: 709: inline Errhandler(MPI_Errhandler obj) : the_real_errhandler(obj) {}
527: 710: inline Errhandler(void) : the_real_errhandler(MPI_ERRHANDLER_NULL) {}
-: 711:
2039: 712: virtual ~Errhandler() {}
-: 713: // copy/assignment
-: 714:
-: 715: Errhandler(const Errhandler &obj) : the_real_errhandler(obj.the_real_errhandler){}
-: 716:
-: 717: Errhandler& operator=(const Errhandler &obj) {
-: 718: the_real_errhandler = obj.the_real_errhandler; return *this; }
-: 719:
-: 720: // logical
3: 721: bool operator== (const Errhandler &obj) {
3: 722: return (the_real_errhandler == obj.the_real_errhandler); }
-: 723: bool operator!= (const Errhandler &obj) {
-: 724: return (the_real_errhandler != obj.the_real_errhandler); }
-: 725: // C/C++ cast and assignment
-: 726: inline operator MPI_Errhandler*() { return &the_real_errhandler; }
-: 727: inline operator MPI_Errhandler() const { return the_real_errhandler; }
-: 728: Errhandler& operator=(const MPI_Errhandler& obj) {
-: 729: the_real_errhandler = obj; return *this; }
3: 730: virtual void Free( void )
-: 731: {
3: 732: MPIX_CALL( MPI_Errhandler_free( (MPI_Errhandler *) &the_real_errhandler ));
3: 733: }
-: 734:};
-: 735:
-: 736:class Request {
-: 737: friend class Comm;
-: 738: friend class File;
-: 739: friend class Grequest;
-: 740:
-: 741: protected:
-: 742: MPI_Request the_real_request;
-: 743:
-: 744: public:
-: 745: // new/delete
-: 746:
-: 747: inline Request(MPI_Request obj) : the_real_request(obj) {}
509: 748: inline Request(void) : the_real_request(MPI_REQUEST_NULL) {}
-: 749:
509: 750: virtual ~Request() {}
-: 751: // copy/assignment
-: 752:
-: 753: Request(const Request &obj) : the_real_request(obj.the_real_request){}
-: 754:
-: 755: Request& operator=(const Request &obj) {
-: 756: the_real_request = obj.the_real_request; return *this; }
-: 757:
-: 758: // logical
-: 759: bool operator== (const Request &obj) {
-: 760: return (the_real_request == obj.the_real_request); }
-: 761: bool operator!= (const Request &obj) {
-: 762: return (the_real_request != obj.the_real_request); }
-: 763: // C/C++ cast and assignment
-: 764: inline operator MPI_Request*() { return &the_real_request; }
-: 765: inline operator MPI_Request() const { return the_real_request; }
-: 766: Request& operator=(const MPI_Request& obj) {
-: 767: the_real_request = obj; return *this; }
-: 768: static bool Testany( int v1, Request v2[], int &v3, Status & v5 )
-: 769: {
-: 770: int v4;
-: 771: MPI_Request *l2 = new MPI_Request[v1];
-: 772: {
-: 773: int i2;
-: 774: for (i2=0;i2<v1;i2++) {
-: 775: l2[i2] = v2[i2].the_real_request;
-: 776: }
-: 777: }
-: 778: MPIX_CALL( MPI_Testany( v1, l2, &v3, &v4, (MPI_Status *)&(v5.the_real_status ) ));
-: 779: {
-: 780: int i2;
-: 781: for (i2=0;i2<v1;i2++) {
-: 782: v2[i2].the_real_request = l2[i2];
-: 783: }
-: 784: delete[] l2;
-: 785: }
-: 786: return v4!= 0;
-: 787: }
-: 788: static bool Testany( int v1, Request v2[], int &v3 )
-: 789: {
-: 790: int v4;
-: 791: MPI_Request *l2 = new MPI_Request[v1];
-: 792: {
-: 793: int i2;
-: 794: for (i2=0;i2<v1;i2++) {
-: 795: l2[i2] = v2[i2].the_real_request;
-: 796: }
-: 797: }
-: 798: MPIX_CALL( MPI_Testany( v1, l2, &v3, &v4, MPI_STATUS_IGNORE ));
-: 799: {
-: 800: int i2;
-: 801: for (i2=0;i2<v1;i2++) {
-: 802: v2[i2].the_real_request = l2[i2];
-: 803: }
-: 804: delete[] l2;
-: 805: }
-: 806: return v4!= 0;
-: 807: }
-: 808: static int Waitsome( int v1, Request v2[], int * v4, Status v5[] )
-: 809: {
-: 810: int v3;
-: 811: MPI_Request *l2 = new MPI_Request[v1];
-: 812: MPI_Status *l5 = new MPI_Status[v1];
-: 813: {
-: 814: int i2;
-: 815: for (i2=0;i2<v1;i2++) {
-: 816: l2[i2] = v2[i2].the_real_request;
-: 817: }
-: 818: }
-: 819: MPIX_CALL( MPI_Waitsome( v1, l2, &v3, v4, l5 ));
-: 820: {
-: 821: int i2;
-: 822: for (i2=0;i2<v1;i2++) {
-: 823: v2[i2].the_real_request = l2[i2];
-: 824: }
-: 825: delete[] l2;
-: 826: }
-: 827: {
-: 828: int i5;
-: 829: for (i5=0;i5<v1;i5++) {
-: 830: v5[i5].the_real_status = l5[i5];
-: 831: }
-: 832: delete[] l5;
-: 833: }
-: 834: return v3;
-: 835: }
-: 836: static int Waitsome( int v1, Request v2[], int * v4 )
-: 837: {
-: 838: int v3;
-: 839: MPI_Request *l2 = new MPI_Request[v1];
-: 840: {
-: 841: int i2;
-: 842: for (i2=0;i2<v1;i2++) {
-: 843: l2[i2] = v2[i2].the_real_request;
-: 844: }
-: 845: }
-: 846: MPIX_CALL( MPI_Waitsome( v1, l2, &v3, v4, MPI_STATUSES_IGNORE ));
-: 847: {
-: 848: int i2;
-: 849: for (i2=0;i2<v1;i2++) {
-: 850: v2[i2].the_real_request = l2[i2];
-: 851: }
-: 852: delete[] l2;
-: 853: }
-: 854: return v3;
-: 855: }
|
#####: 856: virtual void Free( void )
-: 857: {
#####: 858: MPIX_CALL( MPI_Request_free( (MPI_Request *) &the_real_request ));
#####: 859: }
-: 860: static bool Testall( int v1, Request v2[], Status v4[] )
-: 861: {
-: 862: int v3;
-: 863: MPI_Request *l2 = new MPI_Request[v1];
-: 864: MPI_Status *l4 = new MPI_Status[v1];
-: 865: {
-: 866: int i2;
-: 867: for (i2=0;i2<v1;i2++) {
-: 868: l2[i2] = v2[i2].the_real_request;
-: 869: }
-: 870: }
-: 871: MPIX_CALL( MPI_Testall( v1, l2, &v3, l4 ));
-: 872: {
-: 873: int i2;
-: 874: for (i2=0;i2<v1;i2++) {
-: 875: v2[i2].the_real_request = l2[i2];
-: 876: }
-: 877: delete[] l2;
-: 878: }
-: 879: {
-: 880: int i4;
-: 881: for (i4=0;i4<v1;i4++) {
-: 882: v4[i4].the_real_status = l4[i4];
-: 883: }
-: 884: delete[] l4;
-: 885: }
-: 886: return v3!= 0;
-: 887: }
-: 888: static bool Testall( int v1, Request v2[] )
-: 889: {
-: 890: int v3;
-: 891: MPI_Request *l2 = new MPI_Request[v1];
-: 892: {
-: 893: int i2;
-: 894: for (i2=0;i2<v1;i2++) {
-: 895: l2[i2] = v2[i2].the_real_request;
-: 896: }
-: 897: }
-: 898: MPIX_CALL( MPI_Testall( v1, l2, &v3, MPI_STATUSES_IGNORE ));
-: 899: {
-: 900: int i2;
-: 901: for (i2=0;i2<v1;i2++) {
-: 902: v2[i2].the_real_request = l2[i2];
-: 903: }
-: 904: delete[] l2;
-: 905: }
-: 906: return v3!= 0;
-: 907: }
#####: 908: virtual void Wait( Status & v2 )
-: 909: {
#####: 910: MPIX_CALL( MPI_Wait( (MPI_Request *) &the_real_request, (MPI_Status *)&(v2.the_real_status ) ));
#####: 911: }
#####: 912: virtual void Wait( void )
-: 913: {
#####: 914: MPIX_CALL( MPI_Wait( (MPI_Request *) &the_real_request, MPI_STATUS_IGNORE ));
#####: 915: }
-: 916: static int Testsome( int v1, Request v2[], int * v4, Status v5[] )
-: 917: {
-: 918: int v3;
-: 919: MPI_Request *l2 = new MPI_Request[v1];
-: 920: MPI_Status *l5 = new MPI_Status[v1];
-: 921: {
-: 922: int i2;
-: 923: for (i2=0;i2<v1;i2++) {
-: 924: l2[i2] = v2[i2].the_real_request;
-: 925: }
-: 926: }
-: 927: MPIX_CALL( MPI_Testsome( v1, l2, &v3, v4, l5 ));
-: 928: {
-: 929: int i2;
-: 930: for (i2=0;i2<v1;i2++) {
-: 931: v2[i2].the_real_request = l2[i2];
-: 932: }
-: 933: delete[] l2;
-: 934: }
-: 935: {
-: 936: int i5;
-: 937: for (i5=0;i5<v1;i5++) {
-: 938: v5[i5].the_real_status = l5[i5];
-: 939: }
-: 940: delete[] l5;
-: 941: }
-: 942: return v3;
-: 943: }
-: 944: static int Testsome( int v1, Request v2[], int * v4 )
-: 945: {
-: 946: int v3;
-: 947: MPI_Request *l2 = new MPI_Request[v1];
-: 948: {
-: 949: int i2;
-: 950: for (i2=0;i2<v1;i2++) {
-: 951: l2[i2] = v2[i2].the_real_request;
-: 952: }
-: 953: }
-: 954: MPIX_CALL( MPI_Testsome( v1, l2, &v3, v4, MPI_STATUSES_IGNORE ));
-: 955: {
-: 956: int i2;
-: 957: for (i2=0;i2<v1;i2++) {
-: 958: v2[i2].the_real_request = l2[i2];
-: 959: }
-: 960: delete[] l2;
-: 961: }
-: 962: return v3;
-: 963: }
-: 964: static void Waitall( int v1, Request v2[], Status v3[] )
-: 965: {
-: 966: MPI_Request *l2 = new MPI_Request[v1];
-: 967: MPI_Status *l3 = new MPI_Status[v1];
-: 968: {
-: 969: int i2;
-: 970: for (i2=0;i2<v1;i2++) {
-: 971: l2[i2] = v2[i2].the_real_request;
-: 972: }
-: 973: }
-: 974: MPIX_CALL( MPI_Waitall( v1, l2, l3 ));
-: 975: {
-: 976: int i2;
-: 977: for (i2=0;i2<v1;i2++) {
-: 978: v2[i2].the_real_request = l2[i2];
-: 979: }
-: 980: delete[] l2;
-: 981: }
-: 982: {
-: 983: int i3;
-: 984: for (i3=0;i3<v1;i3++) {
-: 985: v3[i3].the_real_status = l3[i3];
-: 986: }
-: 987: delete[] l3;
-: 988: }
-: 989: }
-: 990: static void Waitall( int v1, Request v2[] )
-: 991: {
-: 992: MPI_Request *l2 = new MPI_Request[v1];
-: 993: {
-: 994: int i2;
-: 995: for (i2=0;i2<v1;i2++) {
-: 996: l2[i2] = v2[i2].the_real_request;
-: 997: }
-: 998: }
-: 999: MPIX_CALL( MPI_Waitall( v1, l2, MPI_STATUSES_IGNORE ));
-: 1000: {
-: 1001: int i2;
-: 1002: for (i2=0;i2<v1;i2++) {
-: 1003: v2[i2].the_real_request = l2[i2];
-: 1004: }
-: 1005: delete[] l2;
-: 1006: }
-: 1007: }
-: 1008: static int Waitany( int v1, Request v2[], Status & v4 )
-: 1009: {
-: 1010: int v3;
-: 1011: MPI_Request *l2 = new MPI_Request[v1];
-: 1012: {
-: 1013: int i2;
-: 1014: for (i2=0;i2<v1;i2++) {
-: 1015: l2[i2] = v2[i2].the_real_request;
-: 1016: }
-: 1017: }
-: 1018: MPIX_CALL( MPI_Waitany( v1, l2, &v3, (MPI_Status *)&(v4.the_real_status ) ));
-: 1019: {
-: 1020: int i2;
-: 1021: for (i2=0;i2<v1;i2++) {
-: 1022: v2[i2].the_real_request = l2[i2];
-: 1023: }
-: 1024: delete[] l2;
-: 1025: }
-: 1026: return v3;
-: 1027: }
-: 1028: static int Waitany( int v1, Request v2[] )
-: 1029: {
-: 1030: int v3;
-: 1031: MPI_Request *l2 = new MPI_Request[v1];
-: 1032: {
-: 1033: int i2;
-: 1034: for (i2=0;i2<v1;i2++) {
-: 1035: l2[i2] = v2[i2].the_real_request;
-: 1036: }
-: 1037: }
-: 1038: MPIX_CALL( MPI_Waitany( v1, l2, &v3, MPI_STATUS_IGNORE ));
-: 1039: {
-: 1040: int i2;
-: 1041: for (i2=0;i2<v1;i2++) {
-: 1042: v2[i2].the_real_request = l2[i2];
-: 1043: }
-: 1044: delete[] l2;
-: 1045: }
-: 1046: return v3;
-: 1047: }
#####: 1048: virtual bool Test( Status & v3 )
-: 1049: {
-: 1050: int v2;
#####: 1051: MPIX_CALL( MPI_Test( (MPI_Request *) &the_real_request, &v2, (MPI_Status *)&(v3.the_real_status ) ));
#####: 1052: return v2!= 0;
-: 1053: }
#####: 1054: virtual bool Test( void )
-: 1055: {
-: 1056: int v2;
#####: 1057: MPIX_CALL( MPI_Test( (MPI_Request *) &the_real_request, &v2, MPI_STATUS_IGNORE ));
#####: 1058: return v2!= 0;
-: 1059: }
#####: 1060: virtual void Cancel( void ) const
-: 1061: {
#####: 1062: MPIX_CALL( MPI_Cancel( (MPI_Request *) &the_real_request ));
#####: 1063: }
#####: 1064: virtual bool Get_status( Status & v3 ) const
-: 1065: {
-: 1066: int v2;
#####: 1067: MPIX_CALL( MPI_Request_get_status( (MPI_Request) the_real_request, &v2, (MPI_Status *)&(v3.the_real_status ) ));
#####: 1068: return v2!= 0;
-: 1069: }
#####: 1070: virtual bool Get_status( void ) const
-: 1071: {
-: 1072: int v2;
#####: 1073: MPIX_CALL( MPI_Request_get_status( (MPI_Request) the_real_request, &v2, MPI_STATUS_IGNORE ));
#####: 1074: return v2!= 0;
-: 1075: }
-: 1076:};
-: 1077:
-: 1078:class Prequest : public Request {
-: 1079:
-: 1080: public:
-: 1081: // new/delete
-: 1082:
-: 1083: inline Prequest(MPI_Request obj) : Request(obj) {}
#####: 1084: inline Prequest(void) : Request() {}
-: 1085:
#####: 1086: virtual ~Prequest() {}
-: 1087: // copy/assignment
-: 1088:
-: 1089: Prequest(const Prequest &obj) : Request(obj) {}
-: 1090:
-: 1091: Prequest& operator=(const Prequest &obj) {
-: 1092: the_real_request = obj.the_real_request; return *this; }
-: 1093:
-: 1094: // C/C++ cast and assignment
-: 1095: inline operator MPI_Request*() { return &the_real_request; }
-: 1096: inline operator MPI_Request() const { return the_real_request; }
-: 1097: Prequest& operator=(const MPI_Request& obj) {
-: 1098: the_real_request = obj; return *this; }
#####: 1099: virtual void Start( void )
-: 1100: {
#####: 1101: MPIX_CALL( MPI_Start( (MPI_Request *) &the_real_request ));
#####: 1102: }
-: 1103: static void Startall( int v1, Prequest v2[] )
-: 1104: {
-: 1105: MPI_Request *l2 = new MPI_Request[v1];
-: 1106: {
-: 1107: int i2;
-: 1108: for (i2=0;i2<v1;i2++) {
-: 1109: l2[i2] = v2[i2].the_real_request;
-: 1110: }
-: 1111: }
-: 1112: MPIX_CALL( MPI_Startall( v1, l2 ));
-: 1113: {
-: 1114: int i2;
-: 1115: for (i2=0;i2<v1;i2++) {
-: 1116: v2[i2].the_real_request = l2[i2];
-: 1117: }
-: 1118: delete[] l2;
-: 1119: }
-: 1120: }
-: 1121:};
-: 1122:
-: 1123:class Comm {
-: 1124: friend class Cartcomm;
-: 1125: friend class Intercomm;
-: 1126: friend class Intracomm;
-: 1127: friend class Graphcomm;
-: 1128: friend class Nullcomm;
-: 1129: friend class Datatype;
-: 1130: friend class Win;
-: 1131: friend class File;
-: 1132:
-: 1133: protected:
-: 1134: MPI_Comm the_real_comm;
-: 1135:
-: 1136: public:
-: 1137: // new/delete
-: 1138:
|
1047: 1139: inline Comm(MPI_Comm obj) : the_real_comm(obj) {}
576: 1140: inline Comm(void) : the_real_comm(MPI_COMM_NULL) {}
-: 1141:
1566: 1142: virtual ~Comm() {}
-: 1143: // copy/assignment
-: 1144:
10: 1145: Comm(const Comm &obj) : the_real_comm(obj.the_real_comm){}
-: 1146:
-: 1147: Comm& operator=(const Comm &obj) {
-: 1148: the_real_comm = obj.the_real_comm; return *this; }
-: 1149:
-: 1150: // logical
-: 1151: bool operator== (const Comm &obj) {
-: 1152: return (the_real_comm == obj.the_real_comm); }
-: 1153: bool operator!= (const Comm &obj) {
-: 1154: return (the_real_comm != obj.the_real_comm); }
-: 1155: // C/C++ cast and assignment
-: 1156: inline operator MPI_Comm*() { return &the_real_comm; }
-: 1157: inline operator MPI_Comm() const { return the_real_comm; }
-: 1158: Comm& operator=(const MPI_Comm& obj) {
-: 1159: the_real_comm = obj; return *this; }
|
#####: 1160: virtual Group Get_group( void ) const
-: 1161: {
#####: 1162: Group v2;
#####: 1163: MPIX_CALL( MPI_Comm_group( (MPI_Comm) the_real_comm, &(v2.the_real_group) ));
#####: 1164: return v2;
-: 1165: }
#####: 1166: virtual int Get_rank( void ) const
-: 1167: {
-: 1168: int v2;
#####: 1169: MPIX_CALL( MPI_Comm_rank( (MPI_Comm) the_real_comm, &v2 ));
#####: 1170: return v2;
-: 1171: }
#####: 1172: virtual Prequest Bsend_init( const void* v1, int v2, const Datatype &v3, int v4, int v5 ) const
-: 1173: {
#####: 1174: Prequest v7;
#####: 1175: MPIX_CALL( MPI_Bsend_init( (void*)v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, (MPI_Comm) the_real_comm, &(v7.the_real_request) ));
#####: 1176: return v7;
-: 1177: }
#####: 1178: virtual Prequest Ssend_init( const void* v1, int v2, const Datatype &v3, int v4, int v5 ) const
-: 1179: {
#####: 1180: Prequest v7;
#####: 1181: MPIX_CALL( MPI_Ssend_init( (void*)v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, (MPI_Comm) the_real_comm, &(v7.the_real_request) ));
#####: 1182: return v7;
-: 1183: }
#####: 1184: virtual bool Is_inter( void ) const
-: 1185: {
-: 1186: int v2;
#####: 1187: MPIX_CALL( MPI_Comm_test_inter( (MPI_Comm) the_real_comm, &v2 ));
#####: 1188: return v2!= 0;
-: 1189: }
#####: 1190: virtual Prequest Rsend_init( const void* v1, int v2, const Datatype &v3, int v4, int v5 ) const
-: 1191: {
#####: 1192: Prequest v7;
#####: 1193: MPIX_CALL( MPI_Rsend_init( (void*)v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, (MPI_Comm) the_real_comm, &(v7.the_real_request) ));
#####: 1194: return v7;
-: 1195: }
#####: 1196: virtual Request Ibsend( const void* v1, int v2, const Datatype &v3, int v4, int v5 ) const
-: 1197: {
#####: 1198: Request v7;
#####: 1199: MPIX_CALL( MPI_Ibsend( (void*)v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, (MPI_Comm) the_real_comm, &(v7.the_real_request) ));
#####: 1200: return v7;
-: 1201: }
#####: 1202: virtual void Abort( int v2 ) const
-: 1203: {
#####: 1204: MPIX_CALL( MPI_Abort( (MPI_Comm) the_real_comm, v2 ));
#####: 1205: }
|
80: 1206: virtual void Free( void )
-: 1207: {
80: 1208: MPIX_CALL( MPI_Comm_free( (MPI_Comm *) &the_real_comm ));
80: 1209: }
|
#####: 1210: virtual Prequest Send_init( const void* v1, int v2, const Datatype &v3, int v4, int v5 ) const
-: 1211: {
#####: 1212: Prequest v7;
#####: 1213: MPIX_CALL( MPI_Send_init( (void*)v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, (MPI_Comm) the_real_comm, &(v7.the_real_request) ));
#####: 1214: return v7;
-: 1215: }
#####: 1216: virtual void Recv( void* v1, int v2, const Datatype &v3, int v4, int v5, Status & v7 ) const
-: 1217: {
#####: 1218: MPIX_CALL( MPI_Recv( v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, (MPI_Comm) the_real_comm, (MPI_Status *)&(v7.the_real_status ) ));
#####: 1219: }
#####: 1220: virtual void Recv( void* v1, int v2, const Datatype &v3, int v4, int v5 ) const
-: 1221: {
#####: 1222: MPIX_CALL( MPI_Recv( v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, (MPI_Comm) the_real_comm, MPI_STATUS_IGNORE ));
#####: 1223: }
#####: 1224: virtual void Sendrecv( const void * v1, int v2, const Datatype &v3, int v4, int v5, void * v6, int v7, const Datatype &v8, int v9, int v10, Status & v12 ) const
-: 1225: {
#####: 1226: MPIX_CALL( MPI_Sendrecv( (void *)v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, v6, v7, (MPI_Datatype)(v8.the_real_datatype), v9, v10, (MPI_Comm) the_real_comm, (MPI_Status *)&(v12.the_real_status ) ));
#####: 1227: }
#####: 1228: virtual void Sendrecv( const void * v1, int v2, const Datatype &v3, int v4, int v5, void * v6, int v7, const Datatype &v8, int v9, int v10 ) const
-: 1229: {
#####: 1230: MPIX_CALL( MPI_Sendrecv( (void *)v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, v6, v7, (MPI_Datatype)(v8.the_real_datatype), v9, v10, (MPI_Comm) the_real_comm, MPI_STATUS_IGNORE ));
#####: 1231: }
|
8: 1232: virtual void Sendrecv_replace( void* v1, int v2, const Datatype &v3, int v4, int v5, int v6, int v7, Status & v9 ) const
-: 1233: {
8: 1234: MPIX_CALL( MPI_Sendrecv_replace( v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, v6, v7, (MPI_Comm) the_real_comm, (MPI_Status *)&(v9.the_real_status ) ));
8: 1235: }
|
#####: 1236: virtual void Sendrecv_replace( void* v1, int v2, const Datatype &v3, int v4, int v5, int v6, int v7 ) const
-: 1237: {
#####: 1238: MPIX_CALL( MPI_Sendrecv_replace( v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, v6, v7, (MPI_Comm) the_real_comm, MPI_STATUS_IGNORE ));
#####: 1239: }
#####: 1240: virtual int Get_topology( void ) const
-: 1241: {
-: 1242: int v2;
#####: 1243: MPIX_CALL( MPI_Topo_test( (MPI_Comm) the_real_comm, &v2 ));
#####: 1244: return v2;
-: 1245: }
#####: 1246: virtual Request Isend( const void* v1, int v2, const Datatype &v3, int v4, int v5 ) const
-: 1247: {
#####: 1248: Request v7;
#####: 1249: MPIX_CALL( MPI_Isend( (void*)v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, (MPI_Comm) the_real_comm, &(v7.the_real_request) ));
#####: 1250: return v7;
-: 1251: }
#####: 1252: virtual void Probe( int v1, int v2, Status & v4 ) const
-: 1253: {
#####: 1254: MPIX_CALL( MPI_Probe( v1, v2, (MPI_Comm) the_real_comm, (MPI_Status *)&(v4.the_real_status ) ));
#####: 1255: }
#####: 1256: virtual void Probe( int v1, int v2 ) const
-: 1257: {
#####: 1258: MPIX_CALL( MPI_Probe( v1, v2, (MPI_Comm) the_real_comm, MPI_STATUS_IGNORE ));
#####: 1259: }
-: 1260: static int Compare( const Comm &v1, const Comm &v2 )
-: 1261: {
-: 1262: int v3;
-: 1263: MPIX_CALL( MPI_Comm_compare( (MPI_Comm)(v1.the_real_comm), (MPI_Comm)(v2.the_real_comm), &v3 ));
-: 1264: return v3;
-: 1265: }
#####: 1266: virtual int Get_size( void ) const
-: 1267: {
-: 1268: int v2;
#####: 1269: MPIX_CALL( MPI_Comm_size( (MPI_Comm) the_real_comm, &v2 ));
#####: 1270: return v2;
-: 1271: }
#####: 1272: virtual Request Issend( const void* v1, int v2, const Datatype &v3, int v4, int v5 ) const
-: 1273: {
#####: 1274: Request v7;
#####: 1275: MPIX_CALL( MPI_Issend( (void*)v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, (MPI_Comm) the_real_comm, &(v7.the_real_request) ));
#####: 1276: return v7;
-: 1277: }
|
4: 1278: virtual void Set_errhandler( const Errhandler &v2 )
-: 1279: {
4: 1280: MPIX_CALL( MPI_Comm_set_errhandler( (MPI_Comm) the_real_comm, (MPI_Errhandler)(v2.the_real_errhandler) ));
4: 1281: }
|
#####: 1282: virtual void Send( const void* v1, int v2, const Datatype &v3, int v4, int v5 ) const
-: 1283: {
#####: 1284: MPIX_CALL( MPI_Send( (void*)v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, (MPI_Comm) the_real_comm ));
#####: 1285: }
#####: 1286: virtual Request Irsend( const void* v1, int v2, const Datatype &v3, int v4, int v5 ) const
-: 1287: {
#####: 1288: Request v7;
#####: 1289: MPIX_CALL( MPI_Irsend( (void*)v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, (MPI_Comm) the_real_comm, &(v7.the_real_request) ));
#####: 1290: return v7;
-: 1291: }
#####: 1292: virtual void Ssend( const void* v1, int v2, const Datatype &v3, int v4, int v5 ) const
-: 1293: {
#####: 1294: MPIX_CALL( MPI_Ssend( (void*)v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, (MPI_Comm) the_real_comm ));
#####: 1295: }
#####: 1296: virtual Prequest Recv_init( void* v1, int v2, const Datatype &v3, int v4, int v5 ) const
-: 1297: {
#####: 1298: Prequest v7;
#####: 1299: MPIX_CALL( MPI_Recv_init( v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, (MPI_Comm) the_real_comm, &(v7.the_real_request) ));
#####: 1300: return v7;
-: 1301: }
#####: 1302: virtual bool Iprobe( int v1, int v2, Status & v5 ) const
-: 1303: {
-: 1304: int v4;
#####: 1305: MPIX_CALL( MPI_Iprobe( v1, v2, (MPI_Comm) the_real_comm, &v4, (MPI_Status *)&(v5.the_real_status ) ));
#####: 1306: return v4!= 0;
-: 1307: }
#####: 1308: virtual bool Iprobe( int v1, int v2 ) const
-: 1309: {
-: 1310: int v4;
#####: 1311: MPIX_CALL( MPI_Iprobe( v1, v2, (MPI_Comm) the_real_comm, &v4, MPI_STATUS_IGNORE ));
#####: 1312: return v4!= 0;
-: 1313: }
#####: 1314: virtual void Bsend( const void* v1, int v2, const Datatype &v3, int v4, int v5 ) const
-: 1315: {
#####: 1316: MPIX_CALL( MPI_Bsend( (void*)v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, (MPI_Comm) the_real_comm ));
#####: 1317: }
#####: 1318: virtual Request Irecv( void* v1, int v2, const Datatype &v3, int v4, int v5 ) const
-: 1319: {
#####: 1320: Request v7;
#####: 1321: MPIX_CALL( MPI_Irecv( v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, (MPI_Comm) the_real_comm, &(v7.the_real_request) ));
#####: 1322: return v7;
-: 1323: }
|
4: 1324: virtual Errhandler Get_errhandler( void ) const
-: 1325: {
4: 1326: Errhandler v2;
4: 1327: MPIX_CALL( MPI_Comm_get_errhandler( (MPI_Comm) the_real_comm, &(v2.the_real_errhandler) ));
|
#####: 1328: return v2;
-: 1329: }
#####: 1330: virtual void Rsend( const void* v1, int v2, const Datatype &v3, int v4, int v5 ) const
-: 1331: {
#####: 1332: MPIX_CALL( MPI_Rsend( (void*)v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, (MPI_Comm) the_real_comm ));
#####: 1333: }
#####: 1334: virtual void Reduce_scatter_block( const void * v1, void * v2, int v3, const Datatype &v4, const Op &v5 ) const
-: 1335: {
#####: 1336: MPIX_CALL( MPI_Reduce_scatter_block( (void *)v1, v2, v3, (MPI_Datatype)(v4.the_real_datatype), (MPI_Op)(v5.the_real_op), (MPI_Comm) the_real_comm ));
#####: 1337: }
#####: 1338: virtual void Gatherv( const void* v1, int v2, const Datatype &v3, void* v4, const int * v5, const int * v6, const Datatype &v7, int v8 ) const
-: 1339: {
#####: 1340: MPIX_CALL( MPI_Gatherv( (void*)v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, (int *)v5, (int *)v6, (MPI_Datatype)(v7.the_real_datatype), v8, (MPI_Comm) the_real_comm ));
#####: 1341: }
#####: 1342: virtual void Disconnect( void )
-: 1343: {
#####: 1344: MPIX_CALL( MPI_Comm_disconnect( (MPI_Comm *) &the_real_comm ));
#####: 1345: }
#####: 1346: virtual void Allreduce( const void* v1, void* v2, int v3, const Datatype &v4, const Op &v5 ) const
-: 1347: {
#####: 1348: MPIX_CALL( MPI_Allreduce( (void*)v1, v2, v3, (MPI_Datatype)(v4.the_real_datatype), (MPI_Op)(v5.the_real_op), (MPI_Comm) the_real_comm ));
#####: 1349: }
#####: 1350: virtual void Alltoallw( const void * v1, const int v2[], const int v3[], const Datatype v4[], void * v5, const int v6[], const int v7[], const Datatype v8[] ) const
-: 1351: {
#####: 1352: MPI_Datatype *l4 = new MPI_Datatype[Get_size()];
#####: 1353: MPI_Datatype *l8 = new MPI_Datatype[Get_size()];
-: 1354: {
-: 1355: int i4;
#####: 1356: for (i4=0;i4<Get_size();i4++) {
#####: 1357: l4[i4] = v4[i4].the_real_datatype;
-: 1358: }
-: 1359: }
-: 1360: {
-: 1361: int i8;
#####: 1362: for (i8=0;i8<Get_size();i8++) {
#####: 1363: l8[i8] = v8[i8].the_real_datatype;
-: 1364: }
-: 1365: }
#####: 1366: MPIX_CALL( MPI_Alltoallw( (void *)v1, (int *)v2, (int *)v3, l4, v5, (int *)v6, (int *)v7, l8, (MPI_Comm) the_real_comm ));
#####: 1367: delete[] l4;
#####: 1368: delete[] l8;
#####: 1369: }
-: 1370: static Intercomm Join( const int v1 ) ;
#####: 1371: virtual void Alltoall( const void* v1, int v2, const Datatype &v3, void* v4, int v5, const Datatype &v6 ) const
-: 1372: {
#####: 1373: MPIX_CALL( MPI_Alltoall( (void*)v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, (MPI_Datatype)(v6.the_real_datatype), (MPI_Comm) the_real_comm ));
#####: 1374: }
#####: 1375: virtual bool Get_attr( int v2, void * v3 ) const
-: 1376: {
-: 1377: int v4;
#####: 1378: MPIX_CALL( MPI_Comm_get_attr( (MPI_Comm) the_real_comm, v2, v3, &v4 ));
#####: 1379: return v4!= 0;
-: 1380: }
#####: 1381: virtual void Barrier( void ) const
-: 1382: {
#####: 1383: MPIX_CALL( MPI_Barrier( (MPI_Comm) the_real_comm ));
#####: 1384: }
#####: 1385: virtual void Bcast( void* v1, int v2, const Datatype &v3, int v4 ) const
-: 1386: {
#####: 1387: MPIX_CALL( MPI_Bcast( v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, (MPI_Comm) the_real_comm ));
#####: 1388: }
#####: 1389: virtual void Set_attr( int v2, const void * v3 )
-: 1390: {
#####: 1391: MPIX_CALL( MPI_Comm_set_attr( (MPI_Comm) the_real_comm, v2, (void *)v3 ));
#####: 1392: }
#####: 1393: virtual void Set_name( const char * v2 )
-: 1394: {
#####: 1395: MPIX_CALL( MPI_Comm_set_name( (MPI_Comm) the_real_comm, (char *)v2 ));
#####: 1396: }
-: 1397: static Intercomm Get_parent( void ) ;
#####: 1398: virtual void Alltoallv( const void* v1, const int * v2, const int * v3, const Datatype &v4, void* v5, const int * v6, const int * v7, const Datatype &v8 ) const
-: 1399: {
#####: 1400: MPIX_CALL( MPI_Alltoallv( (void*)v1, (int *)v2, (int *)v3, (MPI_Datatype)(v4.the_real_datatype), v5, (int *)v6, (int *)v7, (MPI_Datatype)(v8.the_real_datatype), (MPI_Comm) the_real_comm ));
#####: 1401: }
#####: 1402: virtual void Reduce_scatter( const void* v1, void* v2, int * v3, const Datatype &v4, const Op &v5 ) const
-: 1403: {
#####: 1404: MPIX_CALL( MPI_Reduce_scatter( (void*)v1, v2, v3, (MPI_Datatype)(v4.the_real_datatype), (MPI_Op)(v5.the_real_op), (MPI_Comm) the_real_comm ));
#####: 1405: }
#####: 1406: virtual void Scatter( const void* v1, int v2, const Datatype &v3, void* v4, int v5, const Datatype &v6, int v7 ) const
-: 1407: {
#####: 1408: MPIX_CALL( MPI_Scatter( (void*)v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, (MPI_Datatype)(v6.the_real_datatype), v7, (MPI_Comm) the_real_comm ));
#####: 1409: }
-: 1410: virtual void Call_errhandler( int v2 ) const;
#####: 1411: virtual void Gather( const void* v1, int v2, const Datatype &v3, void* v4, int v5, const Datatype &v6, int v7 ) const
-: 1412: {
#####: 1413: MPIX_CALL( MPI_Gather( (void*)v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, (MPI_Datatype)(v6.the_real_datatype), v7, (MPI_Comm) the_real_comm ));
#####: 1414: }
-: 1415: static void Free_keyval( int &v1 )
-: 1416: {
-: 1417: MPIX_CALL( MPI_Comm_free_keyval( &v1 ));
-: 1418: }
#####: 1419: virtual void Reduce( const void* v1, void* v2, int v3, const Datatype &v4, const Op &v5, int v6 ) const
-: 1420: {
#####: 1421: MPIX_CALL( MPI_Reduce( (void*)v1, v2, v3, (MPI_Datatype)(v4.the_real_datatype), (MPI_Op)(v5.the_real_op), v6, (MPI_Comm) the_real_comm ));
#####: 1422: }
#####: 1423: virtual void Allgather( const void* v1, int v2, const Datatype &v3, void* v4, int v5, const Datatype &v6 ) const
-: 1424: {
#####: 1425: MPIX_CALL( MPI_Allgather( (void*)v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, (MPI_Datatype)(v6.the_real_datatype), (MPI_Comm) the_real_comm ));
#####: 1426: }
#####: 1427: virtual void Delete_attr( int v2 )
-: 1428: {
#####: 1429: MPIX_CALL( MPI_Comm_delete_attr( (MPI_Comm) the_real_comm, v2 ));
#####: 1430: }
#####: 1431: virtual void Scatterv( const void* v1, const int * v2, const int * v3, const Datatype &v4, void* v5, int v6, const Datatype &v7, int v8 ) const
-: 1432: {
#####: 1433: MPIX_CALL( MPI_Scatterv( (void*)v1, (int *)v2, (int *)v3, (MPI_Datatype)(v4.the_real_datatype), v5, v6, (MPI_Datatype)(v7.the_real_datatype), v8, (MPI_Comm) the_real_comm ));
#####: 1434: }
#####: 1435: virtual void Get_name( char * v2, int &v3 ) const
-: 1436: {
#####: 1437: MPIX_CALL( MPI_Comm_get_name( (MPI_Comm) the_real_comm, v2, &v3 ));
#####: 1438: }
#####: 1439: virtual void Allgatherv( const void* v1, int v2, const Datatype &v3, void* v4, const int * v5, const int * v6, const Datatype &v7 ) const
-: 1440: {
#####: 1441: MPIX_CALL( MPI_Allgatherv( (void*)v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, (int *)v5, (int *)v6, (MPI_Datatype)(v7.the_real_datatype), (MPI_Comm) the_real_comm ));
#####: 1442: }
-: 1443: virtual Comm &Clone(void) const = 0;
-: 1444: typedef int Copy_attr_function(const Comm& oldcomm, int comm_keyval, void* extra_state, void* attribute_val_in, void* attribute_val_out, bool& flag);
-: 1445: typedef int Delete_attr_function(Comm& comm, int comm_keyval, void* attribute_val, void* extra_state);
-: 1446: typedef void Errhandler_function(Comm &, int *, ... );
-: 1447: typedef Errhandler_function Errhandler_fn;
-: 1448:
-: 1449: static int Create_keyval( Copy_attr_function *, Delete_attr_function *,
-: 1450: void * );
-: 1451:
-: 1452: static int NULL_COPY_FN( const Comm &oldcomm, int keyval, void *ex,
#####: 1453: void *attr_in, void *attr_out, bool &flag ) { flag = 0; return 0;}
#####: 1454: static int NULL_DELETE_FN( Comm &comm, int keyval, void * attr, void *ex )
#####: 1455: { return 0; }
-: 1456: static int DUP_FN( const Comm &oldcomm, int keyval, void *ex,
-: 1457: void *attr_in, void *attr_out, bool &flag ) { flag = 1;
-: 1458: *(void **)attr_out = attr_in; return 0;}
-: 1459: static Errhandler Create_errhandler( Errhandler_function * );
-: 1460:
-: 1461:};
-: 1462:
-: 1463:class Nullcomm : public Comm {
-: 1464:
-: 1465: public:
-: 1466: // new/delete
-: 1467:
-: 1468: inline Nullcomm(MPI_Comm obj) : Comm(obj) {}
|
1018: 1469: inline Nullcomm(void) : Comm() {}
-: 1470:
509: 1471: virtual ~Nullcomm() {}
-: 1472: // copy/assignment
-: 1473:
-: 1474: Nullcomm(const Nullcomm &obj) : Comm(obj) {}
-: 1475:
-: 1476: Nullcomm& operator=(const Nullcomm &obj) {
-: 1477: the_real_comm = obj.the_real_comm; return *this; }
-: 1478:
-: 1479: // C/C++ cast and assignment
-: 1480: inline operator MPI_Comm*() { return &the_real_comm; }
-: 1481: inline operator MPI_Comm() const { return the_real_comm; }
-: 1482: Nullcomm& operator=(const MPI_Comm& obj) {
-: 1483: the_real_comm = obj; return *this; }
-: 1484:
-: 1485:// If the compiler does not support variable return types, return a
-: 1486:// reference to Comm. The user must then cast this to the correct type
-: 1487:// (Standard-conforming C++ compilers support variable return types)
-: 1488:#ifdef HAVE_NO_VARIABLE_RETURN_TYPE_SUPPORT
-: 1489: virtual Comm & Clone(void) const {
-: 1490: Comm *clone = new Nullcomm(MPI_COMM_NULL);
-: 1491: return *clone;
-: 1492: };
-: 1493:#else
|
#####: 1494: virtual Nullcomm & Clone(void) const {
#####: 1495: Nullcomm *clone = new Nullcomm();
#####: 1496: return *clone;
-: 1497: };
-: 1498:#endif
-: 1499:};
-: 1500:
-: 1501:class Intercomm : public Comm {
-: 1502: friend class Intracomm;
-: 1503:
-: 1504: public:
-: 1505: // new/delete
-: 1506:
|
20: 1507: inline Intercomm(MPI_Comm obj) : Comm(obj) {}
20: 1508: inline Intercomm(void) : Comm() {}
-: 1509:
20: 1510: virtual ~Intercomm() {}
-: 1511: // copy/assignment
-: 1512:
20: 1513: Intercomm(const Intercomm &obj) : Comm(obj) {}
-: 1514:
10: 1515: Intercomm& operator=(const Intercomm &obj) {
10: 1516: the_real_comm = obj.the_real_comm; return *this; }
-: 1517:
-: 1518: // C/C++ cast and assignment
-: 1519: inline operator MPI_Comm*() { return &the_real_comm; }
-: 1520: inline operator MPI_Comm() const { return the_real_comm; }
-: 1521: Intercomm& operator=(const MPI_Comm& obj) {
-: 1522: the_real_comm = obj; return *this; }
-: 1523: virtual Intracomm Merge( bool v2 ) const;
8: 1524: virtual Group Get_remote_group( void ) const
-: 1525: {
8: 1526: Group v2;
8: 1527: MPIX_CALL( MPI_Comm_remote_group( (MPI_Comm) the_real_comm, &(v2.the_real_group) ));
|
#####: 1528: return v2;
-: 1529: }
|
65: 1530: virtual int Get_remote_size( void ) const
-: 1531: {
-: 1532: int v2;
65: 1533: MPIX_CALL( MPI_Comm_remote_size( (MPI_Comm) the_real_comm, &v2 ));
65: 1534: return v2;
-: 1535: }
-: 1536: Intercomm Dup( void ) const
-: 1537: {
-: 1538: Intercomm v2;
-: 1539: MPIX_CALL( MPI_Comm_dup( (MPI_Comm) the_real_comm, &(v2.the_real_comm) ));
-: 1540: return v2;
-: 1541: }
|
#####: 1542: virtual Intercomm Split( int v2, int v3 ) const
-: 1543: {
#####: 1544: Intercomm v4;
#####: 1545: MPIX_CALL( MPI_Comm_split( (MPI_Comm) the_real_comm, v2, v3, &(v4.the_real_comm) ));
#####: 1546: return v4;
-: 1547: }
-: 1548:
-: 1549:// If the compiler does not support variable return types, return a
-: 1550:// reference to Comm. The user must then cast this to the correct type
-: 1551:// (Standard-conforming C++ compilers support variable return types)
-: 1552:#ifdef HAVE_NO_VARIABLE_RETURN_TYPE_SUPPORT
-: 1553: virtual Comm & Clone(void) const {
-: 1554: MPI_Comm ncomm;
-: 1555: MPI_Comm_dup( (MPI_Comm)the_real_comm, &ncomm);
-: 1556: Comm *clone = new Intercomm(ncomm);
-: 1557: return *clone;
-: 1558: };
-: 1559:#else
#####: 1560: virtual Intercomm & Clone(void) const {
-: 1561: MPI_Comm ncomm;
#####: 1562: MPI_Comm_dup( (MPI_Comm)the_real_comm, &ncomm);
#####: 1563: Intercomm *clone = new Intercomm(ncomm);
#####: 1564: return *clone;
-: 1565: };
-: 1566:#endif
-: 1567:};
-: 1568:
-: 1569:class Intracomm : public Comm {
-: 1570: friend class Cartcomm;
-: 1571: friend class Graphcomm;
-: 1572: friend class Datatype;
-: 1573:
-: 1574: public:
-: 1575: // new/delete
-: 1576:
|
2074: 1577: inline Intracomm(MPI_Comm obj) : Comm(obj) {}
114: 1578: inline Intracomm(void) : Comm() {}
-: 1579:
1037: 1580: virtual ~Intracomm() {}
-: 1581: // copy/assignment
-: 1582:
-: 1583: Intracomm(const Intracomm &obj) : Comm(obj) {}
-: 1584:
-: 1585: Intracomm& operator=(const Intracomm &obj) {
-: 1586: the_real_comm = obj.the_real_comm; return *this; }
-: 1587:
-: 1588: // C/C++ cast and assignment
-: 1589: inline operator MPI_Comm*() { return &the_real_comm; }
-: 1590: inline operator MPI_Comm() const { return the_real_comm; }
-: 1591: Intracomm& operator=(const MPI_Comm& obj) {
-: 1592: the_real_comm = obj; return *this; }
|
#####: 1593: virtual Intercomm Create_intercomm( int v2, const Comm &v3, int v4, int v5 ) const
-: 1594: {
#####: 1595: Intercomm v6;
#####: 1596: MPIX_CALL( MPI_Intercomm_create( (MPI_Comm) the_real_comm, v2, (MPI_Comm)(v3.the_real_comm), v4, v5, &(v6.the_real_comm) ));
#####: 1597: return v6;
-: 1598: }
#####: 1599: virtual Intracomm Split( int v2, int v3 ) const
-: 1600: {
#####: 1601: Intracomm v4;
#####: 1602: MPIX_CALL( MPI_Comm_split( (MPI_Comm) the_real_comm, v2, v3, &(v4.the_real_comm) ));
#####: 1603: return v4;
-: 1604: }
-: 1605: virtual Graphcomm Create_graph( int v2, const int * v3, const int * v4, bool v5 ) const;
-: 1606: virtual Cartcomm Create_cart( int v2, const int * v3, const bool v4[], bool v5 ) const;
#####: 1607: virtual Intracomm Create( const Group &v2 ) const
-: 1608: {
#####: 1609: Intracomm v3;
#####: 1610: MPIX_CALL( MPI_Comm_create( (MPI_Comm) the_real_comm, (MPI_Group)(v2.the_real_group), &(v3.the_real_comm) ));
#####: 1611: return v3;
-: 1612: }
-: 1613: Intracomm Dup( void ) const
-: 1614: {
-: 1615: Intracomm v2;
-: 1616: MPIX_CALL( MPI_Comm_dup( (MPI_Comm) the_real_comm, &(v2.the_real_comm) ));
-: 1617: return v2;
-: 1618: }
#####: 1619: virtual void Scan( const void* v1, void* v2, int v3, const Datatype &v4, const Op &v5 ) const
-: 1620: {
#####: 1621: MPIX_CALL( MPI_Scan( (void*)v1, v2, v3, (MPI_Datatype)(v4.the_real_datatype), (MPI_Op)(v5.the_real_op), (MPI_Comm) the_real_comm ));
#####: 1622: }
#####: 1623: virtual void Exscan( const void * v1, void * v2, int v3, const Datatype &v4, const Op &v5 ) const
-: 1624: {
#####: 1625: MPIX_CALL( MPI_Exscan( (void *)v1, v2, v3, (MPI_Datatype)(v4.the_real_datatype), (MPI_Op)(v5.the_real_op), (MPI_Comm) the_real_comm ));
#####: 1626: }
#####: 1627: virtual Intercomm Accept( const char * v1, const Info &v2, int v3 ) const
-: 1628: {
#####: 1629: Intercomm v5;
#####: 1630: MPIX_CALL( MPI_Comm_accept( (char *)v1, (MPI_Info)(v2.the_real_info), v3, (MPI_Comm) the_real_comm, &(v5.the_real_comm) ));
#####: 1631: return v5;
-: 1632: }
#####: 1633: virtual Intercomm Connect( const char * v1, const Info &v2, int v3 ) const
-: 1634: {
#####: 1635: Intercomm v5;
#####: 1636: MPIX_CALL( MPI_Comm_connect( (char *)v1, (MPI_Info)(v2.the_real_info), v3, (MPI_Comm) the_real_comm, &(v5.the_real_comm) ));
#####: 1637: return v5;
-: 1638: }
-: 1639:
-: 1640:// If the compiler does not support variable return types, return a
-: 1641:// reference to Comm. The user must then cast this to the correct type
-: 1642:// (Standard-conforming C++ compilers support variable return types)
-: 1643:#ifdef HAVE_NO_VARIABLE_RETURN_TYPE_SUPPORT
-: 1644: virtual Comm & Clone(void) const {
-: 1645: MPI_Comm ncomm;
-: 1646: MPI_Comm_dup( (MPI_Comm)the_real_comm, &ncomm);
-: 1647: Comm *clone = new Intracomm(ncomm);
-: 1648: return *clone;
-: 1649: };
-: 1650:#else
#####: 1651: virtual Intracomm & Clone(void) const {
-: 1652: MPI_Comm ncomm;
#####: 1653: MPI_Comm_dup( (MPI_Comm)the_real_comm, &ncomm);
#####: 1654: Intracomm *clone = new Intracomm(ncomm);
#####: 1655: return *clone;
-: 1656: };
-: 1657:#endif
-: 1658:
-: 1659:Intercomm Spawn(const char* command, const char* argv[], int maxprocs, const MPI::Info& info, int root) const {
-: 1660: Intercomm ic;
-: 1661: MPIX_CALL( MPI_Comm_spawn( (char *)command, (char **)argv,
-: 1662: maxprocs, info.the_real_info, root, the_real_comm,
-: 1663: &(ic.the_real_comm), MPI_ERRCODES_IGNORE ) );
-: 1664: return ic;
-: 1665:}
-: 1666:Intercomm Spawn(const char* command, const char* argv[], int maxprocs, const MPI::Info& info, int root, int array_of_errcodes[]) const {
-: 1667: Intercomm ic;
-: 1668: MPIX_CALL( MPI_Comm_spawn( (char *)command, (char **)argv,
-: 1669: maxprocs, info.the_real_info, root, the_real_comm,
-: 1670: &(ic.the_real_comm), array_of_errcodes ) );
-: 1671: return ic;
-: 1672:}
-: 1673:Intercomm Spawn_multiple(int count, const char* array_of_commands[], const char** array_of_argv[], const int array_of_maxprocs[], const MPI::Info array_of_info[], int root) {
-: 1674: Intercomm ic;
-: 1675: MPI_Info *li = new MPI_Info [count];
-: 1676: int i;
-: 1677: for (i=0; i<count; i++) {
-: 1678: li[i] = array_of_info[i].the_real_info;
-: 1679: }
-: 1680: MPIX_CALL( MPI_Comm_spawn_multiple( count, (char **)array_of_commands,
-: 1681: (char ***)array_of_argv, (int *)array_of_maxprocs,
-: 1682: li, root, the_real_comm, &(ic.the_real_comm),
-: 1683: MPI_ERRCODES_IGNORE ) );
-: 1684: delete [] li;
-: 1685: return ic;
-: 1686:}
-: 1687:Intercomm Spawn_multiple(int count, const char* array_of_commands[], const char** array_of_argv[], const int array_of_maxprocs[], const MPI::Info array_of_info[], int root, int array_of_errcodes[]) {
-: 1688: Intercomm ic;
-: 1689: MPI_Info *li = new MPI_Info [count];
-: 1690: int i;
-: 1691: for (i=0; i<count; i++) {
-: 1692: li[i] = array_of_info[i].the_real_info;
-: 1693: }
-: 1694: MPIX_CALL( MPI_Comm_spawn_multiple( count, (char **)array_of_commands,
-: 1695: (char ***)array_of_argv, (int *)array_of_maxprocs,
-: 1696: li, root, the_real_comm, &(ic.the_real_comm),
-: 1697: array_of_errcodes ) );
-: 1698: delete [] li;
-: 1699: return ic;
-: 1700:}
-: 1701:
-: 1702:};
-: 1703:
-: 1704:class Grequest : public Request {
-: 1705:
-: 1706: public:
-: 1707: // new/delete
-: 1708:
-: 1709: inline Grequest(MPI_Request obj) : Request(obj) {}
#####: 1710: inline Grequest(void) : Request() {}
-: 1711:
#####: 1712: virtual ~Grequest() {}
-: 1713: // copy/assignment
-: 1714:
-: 1715: Grequest(const Grequest &obj) : Request(obj) {}
-: 1716:
-: 1717: Grequest& operator=(const Grequest &obj) {
-: 1718: the_real_request = obj.the_real_request; return *this; }
-: 1719:
-: 1720: // logical
-: 1721: bool operator== (const Grequest &obj) {
-: 1722: return (the_real_request == obj.the_real_request); }
-: 1723: bool operator!= (const Grequest &obj) {
-: 1724: return (the_real_request != obj.the_real_request); }
-: 1725: // C/C++ cast and assignment
-: 1726: inline operator MPI_Request*() { return &the_real_request; }
-: 1727: inline operator MPI_Request() const { return the_real_request; }
-: 1728: Grequest& operator=(const MPI_Request& obj) {
-: 1729: the_real_request = obj; return *this; }
#####: 1730: virtual void Complete( void )
-: 1731: {
#####: 1732: MPIX_CALL( MPI_Grequest_complete( (MPI_Request) the_real_request ));
#####: 1733: }
-: 1734:
-: 1735: typedef int Query_function( void *, Status & );
-: 1736: typedef int Free_function( void * );
-: 1737: typedef int Cancel_function( void *, bool );
-: 1738:
-: 1739: Grequest Start( Query_function *query_fn,
-: 1740: Free_function *free_fn,
-: 1741: Cancel_function *cancel_fn,
-: 1742: void *extra_state );
-: 1743:};
-: 1744:
-: 1745:class Win {
-: 1746:
-: 1747: protected:
-: 1748: MPI_Win the_real_win;
-: 1749:
-: 1750: public:
-: 1751: // new/delete
-: 1752:
|
4: 1753: inline Win(MPI_Win obj) : the_real_win(obj) {}
509: 1754: inline Win(void) : the_real_win(MPI_WIN_NULL) {}
-: 1755:
513: 1756: virtual ~Win() {}
-: 1757: // copy/assignment
-: 1758:
-: 1759: Win(const Win &obj) : the_real_win(obj.the_real_win){}
-: 1760:
-: 1761: Win& operator=(const Win &obj) {
-: 1762: the_real_win = obj.the_real_win; return *this; }
-: 1763:
-: 1764: // logical
-: 1765: bool operator== (const Win &obj) {
-: 1766: return (the_real_win == obj.the_real_win); }
-: 1767: bool operator!= (const Win &obj) {
-: 1768: return (the_real_win != obj.the_real_win); }
-: 1769: // C/C++ cast and assignment
-: 1770: inline operator MPI_Win*() { return &the_real_win; }
-: 1771: inline operator MPI_Win() const { return the_real_win; }
-: 1772: Win& operator=(const MPI_Win& obj) {
-: 1773: the_real_win = obj; return *this; }
|
#####: 1774: virtual Group Get_group( void ) const
-: 1775: {
#####: 1776: Group v2;
#####: 1777: MPIX_CALL( MPI_Win_get_group( (MPI_Win) the_real_win, &(v2.the_real_group) ));
#####: 1778: return v2;
-: 1779: }
#####: 1780: virtual void Fence( int v1 ) const
-: 1781: {
#####: 1782: MPIX_CALL( MPI_Win_fence( v1, (MPI_Win) the_real_win ));
#####: 1783: }
#####: 1784: virtual void Start( const Group &v1, int v2 ) const
-: 1785: {
#####: 1786: MPIX_CALL( MPI_Win_start( (MPI_Group)(v1.the_real_group), v2, (MPI_Win) the_real_win ));
#####: 1787: }
|
8: 1788: virtual void Free( void )
-: 1789: {
8: 1790: MPIX_CALL( MPI_Win_free( (MPI_Win *) &the_real_win ));
8: 1791: }
|
#####: 1792: virtual void Put( const void * v1, int v2, const Datatype &v3, int v4, Aint v5, int v6, const Datatype &v7 ) const
-: 1793: {
#####: 1794: MPIX_CALL( MPI_Put( (void *)v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, v6, (MPI_Datatype)(v7.the_real_datatype), (MPI_Win) the_real_win ));
#####: 1795: }
#####: 1796: virtual void Wait( void ) const
-: 1797: {
#####: 1798: MPIX_CALL( MPI_Win_wait( (MPI_Win) the_real_win ));
#####: 1799: }
#####: 1800: virtual bool Test( void ) const
-: 1801: {
-: 1802: int v2;
#####: 1803: MPIX_CALL( MPI_Win_test( (MPI_Win) the_real_win, &v2 ));
#####: 1804: return v2!= 0;
-: 1805: }
#####: 1806: virtual void Get( void * v1, int v2, const Datatype &v3, int v4, Aint v5, int v6, const Datatype &v7 ) const
-: 1807: {
#####: 1808: MPIX_CALL( MPI_Get( v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, v6, (MPI_Datatype)(v7.the_real_datatype), (MPI_Win) the_real_win ));
#####: 1809: }
|
12: 1810: virtual bool Get_attr( int v2, void * v3 ) const
-: 1811: {
-: 1812: int v4;
12: 1813: MPIX_CALL( MPI_Win_get_attr( (MPI_Win) the_real_win, v2, v3, &v4 ));
12: 1814: return v4!= 0;
-: 1815: }
4: 1816: virtual void Set_attr( int v2, const void * v3 )
-: 1817: {
4: 1818: MPIX_CALL( MPI_Win_set_attr( (MPI_Win) the_real_win, v2, (void *)v3 ));
4: 1819: }
|
#####: 1820: virtual void Complete( void ) const
-: 1821: {
#####: 1822: MPIX_CALL( MPI_Win_complete( (MPI_Win) the_real_win ));
#####: 1823: }
|
4: 1824: virtual void Set_errhandler( const Errhandler &v2 )
-: 1825: {
4: 1826: MPIX_CALL( MPI_Win_set_errhandler( (MPI_Win) the_real_win, (MPI_Errhandler)(v2.the_real_errhandler) ));
4: 1827: }
|
#####: 1828: virtual void Set_name( const char * v2 )
-: 1829: {
#####: 1830: MPIX_CALL( MPI_Win_set_name( (MPI_Win) the_real_win, (char *)v2 ));
#####: 1831: }
#####: 1832: virtual void Accumulate( const void * v1, int v2, const Datatype &v3, int v4, Aint v5, int v6, const Datatype &v7, const Op &v8 ) const
-: 1833: {
#####: 1834: MPIX_CALL( MPI_Accumulate( (void *)v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, v6, (MPI_Datatype)(v7.the_real_datatype), (MPI_Op)(v8.the_real_op), (MPI_Win) the_real_win ));
#####: 1835: }
-: 1836: static Win Create( const void * v1, Aint v2, int v3, const Info &v4, const Intracomm &v5 )
-: 1837: {
-: 1838: Win v6;
-: 1839: MPIX_CALL( MPI_Win_create( (void *)v1, v2, v3, (MPI_Info)(v4.the_real_info), (MPI_Comm)(v5.the_real_comm), &(v6.the_real_win) ));
-: 1840: return v6;
-: 1841: }
-: 1842: virtual void Call_errhandler( int v2 ) const;
-: 1843: static void Free_keyval( int &v1 )
-: 1844: {
-: 1845: MPIX_CALL( MPI_Win_free_keyval( &v1 ));
-: 1846: }
#####: 1847: virtual void Post( const Group &v1, int v2 ) const
-: 1848: {
#####: 1849: MPIX_CALL( MPI_Win_post( (MPI_Group)(v1.the_real_group), v2, (MPI_Win) the_real_win ));
#####: 1850: }
#####: 1851: virtual void Unlock( int v1 ) const
-: 1852: {
#####: 1853: MPIX_CALL( MPI_Win_unlock( v1, (MPI_Win) the_real_win ));
#####: 1854: }
#####: 1855: virtual void Delete_attr( int v2 )
-: 1856: {
#####: 1857: MPIX_CALL( MPI_Win_delete_attr( (MPI_Win) the_real_win, v2 ));
#####: 1858: }
#####: 1859: virtual void Lock( int v1, int v2, int v3 ) const
-: 1860: {
#####: 1861: MPIX_CALL( MPI_Win_lock( v1, v2, v3, (MPI_Win) the_real_win ));
#####: 1862: }
|
4: 1863: virtual Errhandler Get_errhandler( void ) const
-: 1864: {
4: 1865: Errhandler v2;
4: 1866: MPIX_CALL( MPI_Win_get_errhandler( (MPI_Win) the_real_win, &(v2.the_real_errhandler) ));
|
#####: 1867: return v2;
-: 1868: }
#####: 1869: virtual void Get_name( char * v2, int &v3 ) const
-: 1870: {
#####: 1871: MPIX_CALL( MPI_Win_get_name( (MPI_Win) the_real_win, v2, &v3 ));
#####: 1872: }
-: 1873: typedef void Errhandler_function(Win &, int *, ... );
-: 1874: typedef Errhandler_function Errhandler_fn;
-: 1875:
-: 1876: static Errhandler Create_errhandler( Errhandler_function * );
-: 1877:
-: 1878: typedef int Copy_attr_function(const Win& oldwin, int win_keyval, void* extra_state, void* attribute_val_in, void* attribute_val_out, bool& flag);
-: 1879: typedef int Delete_attr_function(Win& win, int win_keyval, void* attribute_val, void* extra_state);
-: 1880:
-: 1881: static int Create_keyval( Copy_attr_function *, Delete_attr_function *,
-: 1882: void * );
-: 1883: // These functions are *not* part of MPI-2 but are provided
-: 1884: // because they should have been included
-: 1885: static int NULL_COPY_FN( const Win &oldwin, int keyval, void *ex,
#####: 1886: void *attr_in, void *attr_out, bool &flag ) { flag = 1; return 0;}
-: 1887: static int NULL_DELETE_FN( Win &win, int keyval, void * attr,
#####: 1888: void *ex ) { return 0; }
-: 1889: static int DUP_FN( const Win &oldwin, int keyval, void *ex,
-: 1890: void *attr_in, void *attr_out, bool &flag ) { flag = 1;
-: 1891: *(void **)attr_out = attr_in; return 0;}
-: 1892:
-: 1893:
-: 1894:};
-: 1895:#ifndef MPI_FILE_NULL
-: 1896:#define MPI_FILE_NULL 0
-: 1897:typedef int MPI_File;
-: 1898:#endif
-: 1899:
-: 1900:class File {
-: 1901:
-: 1902: protected:
-: 1903: MPI_File the_real_file;
-: 1904:
-: 1905: public:
-: 1906: // new/delete
-: 1907:
|
4: 1908: inline File(MPI_File obj) : the_real_file(obj) {}
509: 1909: inline File(void) : the_real_file(MPI_FILE_NULL) {}
-: 1910:
513: 1911: virtual ~File() {}
-: 1912: // copy/assignment
-: 1913:
-: 1914: File(const File &obj) : the_real_file(obj.the_real_file){}
-: 1915:
-: 1916: File& operator=(const File &obj) {
-: 1917: the_real_file = obj.the_real_file; return *this; }
-: 1918:
-: 1919: // logical
-: 1920: bool operator== (const File &obj) {
-: 1921: return (the_real_file == obj.the_real_file); }
-: 1922: bool operator!= (const File &obj) {
-: 1923: return (the_real_file != obj.the_real_file); }
-: 1924: // C/C++ cast and assignment
-: 1925: inline operator MPI_File*() { return &the_real_file; }
-: 1926: inline operator MPI_File() const { return the_real_file; }
-: 1927: File& operator=(const MPI_File& obj) {
-: 1928: the_real_file = obj; return *this; }
-: 1929:#ifdef MPI_MODE_RDONLY
|
#####: 1930: virtual Aint Get_type_extent( const Datatype &v2 ) const
-: 1931: {
-: 1932: MPI_Aint v3;
#####: 1933: MPIX_CALL( MPI_File_get_type_extent( (MPI_File) the_real_file, (MPI_Datatype)(v2.the_real_datatype), &v3 ));
#####: 1934: return v3;
-: 1935: }
#####: 1936: virtual void Read_ordered_end( void * v2, Status & v3 )
-: 1937: {
#####: 1938: MPIX_CALL( MPI_File_read_ordered_end( (MPI_File) the_real_file, v2, (MPI_Status *)&(v3.the_real_status ) ));
#####: 1939: }
#####: 1940: virtual void Read_ordered_end( void * v2 )
-: 1941: {
#####: 1942: MPIX_CALL( MPI_File_read_ordered_end( (MPI_File) the_real_file, v2, MPI_STATUS_IGNORE ));
#####: 1943: }
#####: 1944: virtual void Seek_shared( Offset v2, int v3 )
-: 1945: {
#####: 1946: MPIX_CALL( MPI_File_seek_shared( (MPI_File) the_real_file, v2, v3 ));
#####: 1947: }
#####: 1948: virtual void Read_ordered( void * v2, int v3, const Datatype &v4, Status & v5 )
-: 1949: {
#####: 1950: MPIX_CALL( MPI_File_read_ordered( (MPI_File) the_real_file, v2, v3, (MPI_Datatype)(v4.the_real_datatype), (MPI_Status *)&(v5.the_real_status ) ));
#####: 1951: }
#####: 1952: virtual void Read_ordered( void * v2, int v3, const Datatype &v4 )
-: 1953: {
#####: 1954: MPIX_CALL( MPI_File_read_ordered( (MPI_File) the_real_file, v2, v3, (MPI_Datatype)(v4.the_real_datatype), MPI_STATUS_IGNORE ));
#####: 1955: }
#####: 1956: virtual Request Iread_shared( void * v2, int v3, const Datatype &v4 )
-: 1957: {
#####: 1958: Request v5;
#####: 1959: MPIX_CALL( MPI_File_iread_shared( (MPI_File) the_real_file, v2, v3, (MPI_Datatype)(v4.the_real_datatype), (MPIO_Request *)&(v5.the_real_request) ));
#####: 1960: return v5;
-: 1961: }
#####: 1962: virtual Info Get_info( void ) const
-: 1963: {
#####: 1964: Info v2;
#####: 1965: MPIX_CALL( MPI_File_get_info( (MPI_File) the_real_file, &(v2.the_real_info) ));
#####: 1966: return v2;
-: 1967: }
#####: 1968: virtual void Write_ordered_begin( const void * v2, int v3, const Datatype &v4 )
-: 1969: {
#####: 1970: MPIX_CALL( MPI_File_write_ordered_begin( (MPI_File) the_real_file, (void *)v2, v3, (MPI_Datatype)(v4.the_real_datatype) ));
#####: 1971: }
#####: 1972: virtual void Set_info( const Info &v2 )
-: 1973: {
#####: 1974: MPIX_CALL( MPI_File_set_info( (MPI_File) the_real_file, (MPI_Info)(v2.the_real_info) ));
#####: 1975: }
#####: 1976: virtual void Write_ordered( const void * v2, int v3, const Datatype &v4, Status & v5 )
-: 1977: {
#####: 1978: MPIX_CALL( MPI_File_write_ordered( (MPI_File) the_real_file, (void *)v2, v3, (MPI_Datatype)(v4.the_real_datatype), (MPI_Status *)&(v5.the_real_status ) ));
#####: 1979: }
#####: 1980: virtual void Write_ordered( const void * v2, int v3, const Datatype &v4 )
-: 1981: {
#####: 1982: MPIX_CALL( MPI_File_write_ordered( (MPI_File) the_real_file, (void *)v2, v3, (MPI_Datatype)(v4.the_real_datatype), MPI_STATUS_IGNORE ));
#####: 1983: }
#####: 1984: virtual void Sync( void )
-: 1985: {
#####: 1986: MPIX_CALL( MPI_File_sync( (MPI_File) the_real_file ));
#####: 1987: }
#####: 1988: virtual void Read( void * v2, int v3, const Datatype &v4, Status & v5 )
-: 1989: {
#####: 1990: MPIX_CALL( MPI_File_read( (MPI_File) the_real_file, v2, v3, (MPI_Datatype)(v4.the_real_datatype), (MPI_Status *)&(v5.the_real_status ) ));
#####: 1991: }
#####: 1992: virtual void Read( void * v2, int v3, const Datatype &v4 )
-: 1993: {
#####: 1994: MPIX_CALL( MPI_File_read( (MPI_File) the_real_file, v2, v3, (MPI_Datatype)(v4.the_real_datatype), MPI_STATUS_IGNORE ));
#####: 1995: }
#####: 1996: virtual void Write_all( const void * v2, int v3, const Datatype &v4, Status & v5 )
-: 1997: {
#####: 1998: MPIX_CALL( MPI_File_write_all( (MPI_File) the_real_file, (void *)v2, v3, (MPI_Datatype)(v4.the_real_datatype), (MPI_Status *)&(v5.the_real_status ) ));
#####: 1999: }
#####: 2000: virtual void Write_all( const void * v2, int v3, const Datatype &v4 )
-: 2001: {
#####: 2002: MPIX_CALL( MPI_File_write_all( (MPI_File) the_real_file, (void *)v2, v3, (MPI_Datatype)(v4.the_real_datatype), MPI_STATUS_IGNORE ));
#####: 2003: }
#####: 2004: virtual Offset Get_size( void ) const
-: 2005: {
-: 2006: MPI_Offset v2;
#####: 2007: MPIX_CALL( MPI_File_get_size( (MPI_File) the_real_file, &v2 ));
#####: 2008: return v2;
-: 2009: }
#####: 2010: virtual void Write_all_end( const void * v2, Status & v3 )
-: 2011: {
#####: 2012: MPIX_CALL( MPI_File_write_all_end( (MPI_File) the_real_file, (void *)v2, (MPI_Status *)&(v3.the_real_status ) ));
#####: 2013: }
#####: 2014: virtual void Write_all_end( const void * v2 )
-: 2015: {
#####: 2016: MPIX_CALL( MPI_File_write_all_end( (MPI_File) the_real_file, (void *)v2, MPI_STATUS_IGNORE ));
#####: 2017: }
-: 2018: static void Delete( const char * v1, const Info &v2 )
-: 2019: {
-: 2020: MPIX_CALL( MPI_File_delete( (char *)v1, (MPI_Info)(v2.the_real_info) ));
-: 2021: }
#####: 2022: virtual void Read_ordered_begin( void * v2, int v3, const Datatype &v4 )
-: 2023: {
#####: 2024: MPIX_CALL( MPI_File_read_ordered_begin( (MPI_File) the_real_file, v2, v3, (MPI_Datatype)(v4.the_real_datatype) ));
#####: 2025: }
#####: 2026: virtual Request Iread_at( Offset v2, void * v3, int v4, const Datatype &v5 )
-: 2027: {
#####: 2028: Request v6;
#####: 2029: MPIX_CALL( MPI_File_iread_at( (MPI_File) the_real_file, v2, v3, v4, (MPI_Datatype)(v5.the_real_datatype), (MPIO_Request *)&(v6.the_real_request) ));
#####: 2030: return v6;
-: 2031: }
#####: 2032: virtual void Write_at_all_end( const void * v2, Status & v3 )
-: 2033: {
#####: 2034: MPIX_CALL( MPI_File_write_at_all_end( (MPI_File) the_real_file, (void *)v2, (MPI_Status *)&(v3.the_real_status ) ));
#####: 2035: }
#####: 2036: virtual void Write_at_all_end( const void * v2 )
-: 2037: {
#####: 2038: MPIX_CALL( MPI_File_write_at_all_end( (MPI_File) the_real_file, (void *)v2, MPI_STATUS_IGNORE ));
#####: 2039: }
#####: 2040: virtual Offset Get_position_shared( void ) const
-: 2041: {
-: 2042: MPI_Offset v2;
#####: 2043: MPIX_CALL( MPI_File_get_position_shared( (MPI_File) the_real_file, &v2 ));
#####: 2044: return v2;
-: 2045: }
#####: 2046: virtual void Write_shared( const void * v2, int v3, const Datatype &v4, Status & v5 )
-: 2047: {
#####: 2048: MPIX_CALL( MPI_File_write_shared( (MPI_File) the_real_file, (void *)v2, v3, (MPI_Datatype)(v4.the_real_datatype), (MPI_Status *)&(v5.the_real_status ) ));
#####: 2049: }
#####: 2050: virtual void Write_shared( const void * v2, int v3, const Datatype &v4 )
-: 2051: {
#####: 2052: MPIX_CALL( MPI_File_write_shared( (MPI_File) the_real_file, (void *)v2, v3, (MPI_Datatype)(v4.the_real_datatype), MPI_STATUS_IGNORE ));
#####: 2053: }
#####: 2054: virtual Request Iwrite_at( Offset v2, const void * v3, int v4, const Datatype &v5 )
-: 2055: {
#####: 2056: Request v6;
#####: 2057: MPIX_CALL( MPI_File_iwrite_at( (MPI_File) the_real_file, (MPI_Offset)v2, (void *)v3, v4, (MPI_Datatype)(v5.the_real_datatype), (MPIO_Request *)&(v6.the_real_request) ));
#####: 2058: return v6;
-: 2059: }
#####: 2060: virtual void Get_view( Offset & v2, Datatype &v3, Datatype &v4, char * v5 ) const
-: 2061: {
#####: 2062: MPIX_CALL( MPI_File_get_view( (MPI_File) the_real_file, &v2, (MPI_Datatype *)&(v3.the_real_datatype), (MPI_Datatype *)&(v4.the_real_datatype), v5 ));
#####: 2063: }
-: 2064: virtual void Call_errhandler( int v2 ) const;
#####: 2065: virtual void Write_all_begin( const void * v2, int v3, const Datatype &v4 )
-: 2066: {
#####: 2067: MPIX_CALL( MPI_File_write_all_begin( (MPI_File) the_real_file, (void *)v2, v3, (MPI_Datatype)(v4.the_real_datatype) ));
#####: 2068: }
#####: 2069: virtual void Read_all_end( void * v2, Status & v3 )
-: 2070: {
#####: 2071: MPIX_CALL( MPI_File_read_all_end( (MPI_File) the_real_file, v2, (MPI_Status *)&(v3.the_real_status ) ));
#####: 2072: }
#####: 2073: virtual void Read_all_end( void * v2 )
-: 2074: {
#####: 2075: MPIX_CALL( MPI_File_read_all_end( (MPI_File) the_real_file, v2, MPI_STATUS_IGNORE ));
#####: 2076: }
#####: 2077: virtual Offset Get_byte_offset( const Offset v2 ) const
-: 2078: {
-: 2079: MPI_Offset v3;
#####: 2080: MPIX_CALL( MPI_File_get_byte_offset( (MPI_File) the_real_file, (MPI_Offset)v2, &v3 ));
#####: 2081: return v3;
-: 2082: }
#####: 2083: virtual Request Iread( void * v2, int v3, const Datatype &v4 )
-: 2084: {
#####: 2085: Request v5;
#####: 2086: MPIX_CALL( MPI_File_iread( (MPI_File) the_real_file, v2, v3, (MPI_Datatype)(v4.the_real_datatype), (MPIO_Request *)&(v5.the_real_request) ));
#####: 2087: return v5;
-: 2088: }
#####: 2089: virtual void Read_at_all_end( void * v2, Status & v3 )
-: 2090: {
#####: 2091: MPIX_CALL( MPI_File_read_at_all_end( (MPI_File) the_real_file, v2, (MPI_Status *)&(v3.the_real_status ) ));
#####: 2092: }
#####: 2093: virtual void Read_at_all_end( void * v2 )
-: 2094: {
#####: 2095: MPIX_CALL( MPI_File_read_at_all_end( (MPI_File) the_real_file, v2, MPI_STATUS_IGNORE ));
#####: 2096: }
#####: 2097: virtual void Write_at( Offset v2, const void * v3, int v4, const Datatype &v5, Status & v6 )
-: 2098: {
#####: 2099: MPIX_CALL( MPI_File_write_at( (MPI_File) the_real_file, v2, (void *)v3, v4, (MPI_Datatype)(v5.the_real_datatype), (MPI_Status *)&(v6.the_real_status ) ));
#####: 2100: }
#####: 2101: virtual void Write_at( Offset v2, const void * v3, int v4, const Datatype &v5 )
-: 2102: {
#####: 2103: MPIX_CALL( MPI_File_write_at( (MPI_File) the_real_file, v2, (void *)v3, v4, (MPI_Datatype)(v5.the_real_datatype), MPI_STATUS_IGNORE ));
#####: 2104: }
#####: 2105: virtual void Write_at_all_begin( Offset v2, const void * v3, int v4, const Datatype &v5 )
-: 2106: {
#####: 2107: MPIX_CALL( MPI_File_write_at_all_begin( (MPI_File) the_real_file, v2, (void *)v3, v4, (MPI_Datatype)(v5.the_real_datatype) ));
#####: 2108: }
|
4: 2109: virtual Errhandler Get_errhandler( void ) const
-: 2110: {
4: 2111: Errhandler v2;
4: 2112: MPIX_CALL( MPI_File_get_errhandler( (MPI_File) the_real_file, &(v2.the_real_errhandler) ));
|
#####: 2113: return v2;
-: 2114: }
#####: 2115: virtual int Get_amode( void ) const
-: 2116: {
-: 2117: int v2;
#####: 2118: MPIX_CALL( MPI_File_get_amode( (MPI_File) the_real_file, &v2 ));
#####: 2119: return v2;
-: 2120: }
#####: 2121: virtual void Set_atomicity( bool v2 )
-: 2122: {
-: 2123: int l2;
#####: 2124: l2 = (v2 == true) ? 1 : 0;
#####: 2125: MPIX_CALL( MPI_File_set_atomicity( (MPI_File) the_real_file, l2 ));
#####: 2126: }
#####: 2127: virtual Group Get_group( void ) const
-: 2128: {
#####: 2129: Group v2;
#####: 2130: MPIX_CALL( MPI_File_get_group( (MPI_File) the_real_file, &(v2.the_real_group) ));
#####: 2131: return v2;
-: 2132: }
#####: 2133: virtual Offset Get_position( void ) const
-: 2134: {
-: 2135: MPI_Offset v2;
#####: 2136: MPIX_CALL( MPI_File_get_position( (MPI_File) the_real_file, &v2 ));
#####: 2137: return v2;
-: 2138: }
-: 2139: static File Open( const Intracomm &v1, const char * v2, int v3, const Info &v4 )
-: 2140: {
-: 2141: File v5;
-: 2142: MPIX_CALL( MPI_File_open( (MPI_Comm)(v1.the_real_comm), (char *)v2, v3, (MPI_Info)(v4.the_real_info), &(v5.the_real_file) ));
-: 2143: return v5;
-: 2144: }
#####: 2145: virtual void Seek( Offset v2, int v3 )
-: 2146: {
#####: 2147: MPIX_CALL( MPI_File_seek( (MPI_File) the_real_file, v2, v3 ));
#####: 2148: }
#####: 2149: virtual void Read_all_begin( void * v2, int v3, const Datatype &v4 )
-: 2150: {
#####: 2151: MPIX_CALL( MPI_File_read_all_begin( (MPI_File) the_real_file, v2, v3, (MPI_Datatype)(v4.the_real_datatype) ));
#####: 2152: }
#####: 2153: virtual void Read_at_all_begin( Offset v2, void * v3, int v4, const Datatype &v5 )
-: 2154: {
#####: 2155: MPIX_CALL( MPI_File_read_at_all_begin( (MPI_File) the_real_file, v2, v3, v4, (MPI_Datatype)(v5.the_real_datatype) ));
#####: 2156: }
#####: 2157: virtual void Read_all( void * v2, int v3, const Datatype &v4, Status & v5 )
-: 2158: {
#####: 2159: MPIX_CALL( MPI_File_read_all( (MPI_File) the_real_file, v2, v3, (MPI_Datatype)(v4.the_real_datatype), (MPI_Status *)&(v5.the_real_status ) ));
#####: 2160: }
#####: 2161: virtual void Read_all( void * v2, int v3, const Datatype &v4 )
-: 2162: {
#####: 2163: MPIX_CALL( MPI_File_read_all( (MPI_File) the_real_file, v2, v3, (MPI_Datatype)(v4.the_real_datatype), MPI_STATUS_IGNORE ));
#####: 2164: }
#####: 2165: virtual void Preallocate( Offset v2 )
-: 2166: {
#####: 2167: MPIX_CALL( MPI_File_preallocate( (MPI_File) the_real_file, v2 ));
#####: 2168: }
#####: 2169: virtual void Read_at_all( Offset v2, void * v3, int v4, const Datatype &v5, Status & v6 )
-: 2170: {
#####: 2171: MPIX_CALL( MPI_File_read_at_all( (MPI_File) the_real_file, v2, v3, v4, (MPI_Datatype)(v5.the_real_datatype), (MPI_Status *)&(v6.the_real_status ) ));
#####: 2172: }
#####: 2173: virtual void Read_at_all( Offset v2, void * v3, int v4, const Datatype &v5 )
-: 2174: {
#####: 2175: MPIX_CALL( MPI_File_read_at_all( (MPI_File) the_real_file, v2, v3, v4, (MPI_Datatype)(v5.the_real_datatype), MPI_STATUS_IGNORE ));
#####: 2176: }
#####: 2177: virtual void Read_shared( void * v2, int v3, const Datatype &v4, Status & v5 )
-: 2178: {
#####: 2179: MPIX_CALL( MPI_File_read_shared( (MPI_File) the_real_file, v2, v3, (MPI_Datatype)(v4.the_real_datatype), (MPI_Status *)&(v5.the_real_status ) ));
#####: 2180: }
#####: 2181: virtual void Read_shared( void * v2, int v3, const Datatype &v4 )
-: 2182: {
#####: 2183: MPIX_CALL( MPI_File_read_shared( (MPI_File) the_real_file, v2, v3, (MPI_Datatype)(v4.the_real_datatype), MPI_STATUS_IGNORE ));
#####: 2184: }
#####: 2185: virtual Request Iwrite( const void * v2, int v3, const Datatype &v4 )
-: 2186: {
#####: 2187: Request v5;
#####: 2188: MPIX_CALL( MPI_File_iwrite( (MPI_File) the_real_file, (void *)v2, v3, (MPI_Datatype)(v4.the_real_datatype), (MPIO_Request *)&(v5.the_real_request) ));
#####: 2189: return v5;
-: 2190: }
#####: 2191: virtual Request Iwrite_shared( const void * v2, int v3, const Datatype &v4 )
-: 2192: {
#####: 2193: Request v5;
#####: 2194: MPIX_CALL( MPI_File_iwrite_shared( (MPI_File) the_real_file, (void *)v2, v3, (MPI_Datatype)(v4.the_real_datatype), (MPIO_Request *)&(v5.the_real_request) ));
#####: 2195: return v5;
-: 2196: }
|
4: 2197: virtual void Set_errhandler( const Errhandler &v2 )
-: 2198: {
4: 2199: MPIX_CALL( MPI_File_set_errhandler( (MPI_File) the_real_file, (MPI_Errhandler)(v2.the_real_errhandler) ));
4: 2200: }
|
#####: 2201: virtual void Write_at_all( Offset v2, const void * v3, int v4, const Datatype &v5, Status & v6 )
-: 2202: {
#####: 2203: MPIX_CALL( MPI_File_write_at_all( (MPI_File) the_real_file, v2, (void *)v3, v4, (MPI_Datatype)(v5.the_real_datatype), (MPI_Status *)&(v6.the_real_status ) ));
#####: 2204: }
#####: 2205: virtual void Write_at_all( Offset v2, const void * v3, int v4, const Datatype &v5 )
-: 2206: {
#####: 2207: MPIX_CALL( MPI_File_write_at_all( (MPI_File) the_real_file, v2, (void *)v3, v4, (MPI_Datatype)(v5.the_real_datatype), MPI_STATUS_IGNORE ));
#####: 2208: }
#####: 2209: virtual void Set_size( Offset v2 )
-: 2210: {
#####: 2211: MPIX_CALL( MPI_File_set_size( (MPI_File) the_real_file, v2 ));
#####: 2212: }
#####: 2213: virtual void Set_view( Offset v2, const Datatype &v3, const Datatype v4, const char * v5, const Info &v6 )
-: 2214: {
#####: 2215: MPIX_CALL( MPI_File_set_view( (MPI_File) the_real_file, v2, (MPI_Datatype)(v3.the_real_datatype), (MPI_Datatype)v4, (char *)v5, (MPI_Info)(v6.the_real_info) ));
#####: 2216: }
#####: 2217: virtual void Read_at( Offset v2, void * v3, int v4, const Datatype &v5, Status & v6 )
-: 2218: {
#####: 2219: MPIX_CALL( MPI_File_read_at( (MPI_File) the_real_file, v2, v3, v4, (MPI_Datatype)(v5.the_real_datatype), (MPI_Status *)&(v6.the_real_status ) ));
#####: 2220: }
#####: 2221: virtual void Read_at( Offset v2, void * v3, int v4, const Datatype &v5 )
-: 2222: {
#####: 2223: MPIX_CALL( MPI_File_read_at( (MPI_File) the_real_file, v2, v3, v4, (MPI_Datatype)(v5.the_real_datatype), MPI_STATUS_IGNORE ));
#####: 2224: }
#####: 2225: virtual void Close( void )
-: 2226: {
#####: 2227: MPIX_CALL( MPI_File_close( (MPI_File *) &the_real_file ));
#####: 2228: }
#####: 2229: virtual void Write_ordered_end( const void * v2, Status & v3 )
-: 2230: {
#####: 2231: MPIX_CALL( MPI_File_write_ordered_end( (MPI_File) the_real_file, (void *)v2, (MPI_Status *)&(v3.the_real_status ) ));
#####: 2232: }
#####: 2233: virtual void Write_ordered_end( const void * v2 )
-: 2234: {
#####: 2235: MPIX_CALL( MPI_File_write_ordered_end( (MPI_File) the_real_file, (void *)v2, MPI_STATUS_IGNORE ));
#####: 2236: }
#####: 2237: virtual void Write( const void * v2, int v3, const Datatype &v4, Status & v5 )
-: 2238: {
#####: 2239: MPIX_CALL( MPI_File_write( (MPI_File) the_real_file, (void *)v2, v3, (MPI_Datatype)(v4.the_real_datatype), (MPI_Status *)&(v5.the_real_status ) ));
#####: 2240: }
#####: 2241: virtual void Write( const void * v2, int v3, const Datatype &v4 )
-: 2242: {
#####: 2243: MPIX_CALL( MPI_File_write( (MPI_File) the_real_file, (void *)v2, v3, (MPI_Datatype)(v4.the_real_datatype), MPI_STATUS_IGNORE ));
#####: 2244: }
#####: 2245: virtual bool Get_atomicity( void ) const
-: 2246: {
-: 2247: int v2;
#####: 2248: MPIX_CALL( MPI_File_get_atomicity( (MPI_File) the_real_file, &v2 ));
#####: 2249: return v2!= 0;
-: 2250: }
-: 2251: typedef void Errhandler_function(File &, int *, ... );
-: 2252: typedef Errhandler_function Errhandler_fn;
-: 2253:
-: 2254: static Errhandler Create_errhandler( Errhandler_function * );
-: 2255:
-: 2256:#endif
-: 2257:};
-: 2258:
-: 2259:class Graphcomm : public Intracomm {
-: 2260:
-: 2261: public:
-: 2262: // new/delete
-: 2263:
#####: 2264: inline Graphcomm(MPI_Comm obj) : Intracomm(obj) {}
|
8: 2265: inline Graphcomm(void) : Intracomm() {}
-: 2266:
|
#####: 2267: virtual ~Graphcomm() {}
-: 2268: // copy/assignment
-: 2269:
-: 2270: Graphcomm(const Graphcomm &obj) : Intracomm(obj) {}
-: 2271:
-: 2272: Graphcomm& operator=(const Graphcomm &obj) {
-: 2273: the_real_comm = obj.the_real_comm; return *this; }
-: 2274:
-: 2275: // C/C++ cast and assignment
-: 2276: inline operator MPI_Comm*() { return &the_real_comm; }
-: 2277: inline operator MPI_Comm() const { return the_real_comm; }
-: 2278: Graphcomm& operator=(const MPI_Comm& obj) {
-: 2279: the_real_comm = obj; return *this; }
#####: 2280: virtual void Get_dims( int * v2, int * v3 ) const
-: 2281: {
#####: 2282: MPIX_CALL( MPI_Graphdims_get( (MPI_Comm) the_real_comm, v2, v3 ));
#####: 2283: }
#####: 2284: virtual void Get_topo( int v2, int v3, int * v4, int * v5 ) const
-: 2285: {
#####: 2286: MPIX_CALL( MPI_Graph_get( (MPI_Comm) the_real_comm, v2, v3, v4, v5 ));
#####: 2287: }
#####: 2288: virtual int Map( int v2, const int * v3, const int * v4 ) const
-: 2289: {
-: 2290: int v5;
#####: 2291: MPIX_CALL( MPI_Graph_map( (MPI_Comm) the_real_comm, v2, (int *)v3, (int *)v4, &v5 ));
#####: 2292: return v5;
-: 2293: }
#####: 2294: virtual void Get_neighbors( int v2, int v3, int * v4 ) const
-: 2295: {
#####: 2296: MPIX_CALL( MPI_Graph_neighbors( (MPI_Comm) the_real_comm, v2, v3, v4 ));
#####: 2297: }
#####: 2298: virtual int Get_neighbors_count( int v2 ) const
-: 2299: {
-: 2300: int v3;
#####: 2301: MPIX_CALL( MPI_Graph_neighbors_count( (MPI_Comm) the_real_comm, v2, &v3 ));
#####: 2302: return v3;
-: 2303: }
-: 2304: Graphcomm Dup( void ) const
-: 2305: {
-: 2306: Graphcomm v2;
-: 2307: MPIX_CALL( MPI_Comm_dup( (MPI_Comm) the_real_comm, &(v2.the_real_comm) ));
-: 2308: return v2;
-: 2309: }
-: 2310:
-: 2311:// If the compiler does not support variable return types, return a
-: 2312:// reference to Comm. The user must then cast this to the correct type
-: 2313:// (Standard-conforming C++ compilers support variable return types)
-: 2314:#ifdef HAVE_NO_VARIABLE_RETURN_TYPE_SUPPORT
-: 2315: virtual Comm & Clone(void) const {
-: 2316: MPI_Comm ncomm;
-: 2317: MPI_Comm_dup( (MPI_Comm)the_real_comm, &ncomm);
-: 2318: Comm *clone = new Graphcomm(ncomm);
-: 2319: return *clone;
-: 2320: };
-: 2321:#else
#####: 2322: virtual Graphcomm & Clone(void) const {
-: 2323: MPI_Comm ncomm;
#####: 2324: MPI_Comm_dup( (MPI_Comm)the_real_comm, &ncomm);
#####: 2325: Graphcomm *clone = new Graphcomm(ncomm);
#####: 2326: return *clone;
-: 2327: };
-: 2328:#endif
-: 2329:};
-: 2330:
-: 2331:class Cartcomm : public Intracomm {
-: 2332:
-: 2333: public:
-: 2334: // new/delete
-: 2335:
#####: 2336: inline Cartcomm(MPI_Comm obj) : Intracomm(obj) {}
|
48: 2337: inline Cartcomm(void) : Intracomm() {}
-: 2338:
|
#####: 2339: virtual ~Cartcomm() {}
-: 2340: // copy/assignment
-: 2341:
-: 2342: Cartcomm(const Cartcomm &obj) : Intracomm(obj) {}
-: 2343:
-: 2344: Cartcomm& operator=(const Cartcomm &obj) {
-: 2345: the_real_comm = obj.the_real_comm; return *this; }
-: 2346:
-: 2347: // C/C++ cast and assignment
-: 2348: inline operator MPI_Comm*() { return &the_real_comm; }
-: 2349: inline operator MPI_Comm() const { return the_real_comm; }
-: 2350: Cartcomm& operator=(const MPI_Comm& obj) {
-: 2351: the_real_comm = obj; return *this; }
#####: 2352: virtual void Get_coords( int v2, int v3, int * v4 ) const
-: 2353: {
#####: 2354: MPIX_CALL( MPI_Cart_coords( (MPI_Comm) the_real_comm, v2, v3, v4 ));
#####: 2355: }
#####: 2356: virtual int Get_cart_rank( const int * v2 ) const
-: 2357: {
-: 2358: int v3;
#####: 2359: MPIX_CALL( MPI_Cart_rank( (MPI_Comm) the_real_comm, (int *)v2, &v3 ));
#####: 2360: return v3;
-: 2361: }
#####: 2362: virtual int Get_dim( void ) const
-: 2363: {
-: 2364: int v2;
#####: 2365: MPIX_CALL( MPI_Cartdim_get( (MPI_Comm) the_real_comm, &v2 ));
#####: 2366: return v2;
-: 2367: }
#####: 2368: virtual void Get_topo( int v2, int * v3, bool v4[], int * v5 ) const
-: 2369: {
#####: 2370: int *l4 = new int[v2];
#####: 2371: MPIX_CALL( MPI_Cart_get( (MPI_Comm) the_real_comm, v2, v3, l4, v5 ));
-: 2372: {
-: 2373: int i4;
#####: 2374: for (i4=0;i4<v2;i4++) {
-: 2375: // Unfortunately, at least one C++ compiler (Microsoft's)
-: 2376: // generates warning messages when the type size changes
-: 2377: // even when an explicit cast is used. To avoid these messages, we
-: 2378: // cause the generated code to explicitly compute a
-: 2379: // boolean value
#####: 2380: v4[i4] = l4[i4] != 0;
-: 2381: }
#####: 2382: delete[] l4;
-: 2383: }
#####: 2384: }
#####: 2385: virtual int Map( int v2, const int * v3, const bool v4[] ) const
-: 2386: {
-: 2387: int v5;
#####: 2388: int *l4 = new int[v2];
-: 2389: {
-: 2390: int i4;
#####: 2391: for (i4=0;i4<v2;i4++) {
#####: 2392: l4[i4] = v4[i4] == true ? 1 : 0;
-: 2393: }
-: 2394: }
#####: 2395: MPIX_CALL( MPI_Cart_map( (MPI_Comm) the_real_comm, v2, (int *)v3, l4, &v5 ));
-: 2396:
#####: 2397: delete[] l4;
#####: 2398: return v5;
-: 2399: }
#####: 2400: virtual Cartcomm Sub( const bool v2[] ) const
-: 2401: {
#####: 2402: Cartcomm v3;
#####: 2403: int *l2 = new int[10];
-: 2404: {
-: 2405: int i2;
#####: 2406: for (i2=0;i2<10;i2++) {
#####: 2407: l2[i2] = v2[i2] == true ? 1 : 0;
-: 2408: }
-: 2409: }
#####: 2410: MPIX_CALL( MPI_Cart_sub( (MPI_Comm) the_real_comm, l2, &(v3.the_real_comm) ));
-: 2411:
#####: 2412: delete[] l2;
#####: 2413: return v3;
-: 2414: }
#####: 2415: virtual void Shift( int v2, int v3, int &v4, int &v5 ) const
-: 2416: {
#####: 2417: MPIX_CALL( MPI_Cart_shift( (MPI_Comm) the_real_comm, v2, v3, &v4, &v5 ));
#####: 2418: }
-: 2419: Cartcomm Dup( void ) const
-: 2420: {
-: 2421: Cartcomm v2;
-: 2422: MPIX_CALL( MPI_Comm_dup( (MPI_Comm) the_real_comm, &(v2.the_real_comm) ));
-: 2423: return v2;
-: 2424: }
-: 2425:
-: 2426:// If the compiler does not support variable return types, return a
-: 2427:// reference to Comm. The user must then cast this to the correct type
-: 2428:// (Standard-conforming C++ compilers support variable return types)
-: 2429:#ifdef HAVE_NO_VARIABLE_RETURN_TYPE_SUPPORT
-: 2430: virtual Comm & Clone(void) const {
-: 2431: MPI_Comm ncomm;
-: 2432: MPI_Comm_dup( (MPI_Comm)the_real_comm, &ncomm);
-: 2433: Comm *clone = new Cartcomm(ncomm);
-: 2434: return *clone;
-: 2435: };
-: 2436:#else
#####: 2437: virtual Cartcomm & Clone(void) const {
-: 2438: MPI_Comm ncomm;
#####: 2439: MPI_Comm_dup( (MPI_Comm)the_real_comm, &ncomm);
#####: 2440: Cartcomm *clone = new Cartcomm(ncomm);
#####: 2441: return *clone;
-: 2442: };
-: 2443:#endif
-: 2444:};
-: 2445:extern int Add_error_class( void ) ;
-: 2446:extern void* Alloc_mem( Aint v1, const Info &v2 ) ;
-: 2447:extern void Lookup_name( const char * v1, const Info &v2, char * v3 ) ;
-: 2448:extern void Publish_name( const char * v1, const Info &v2, const char * v3 ) ;
-: 2449:extern void Unpublish_name( const char * v1, const Info &v2, const char * v3 ) ;
-: 2450:extern Aint Get_address( void * v1 ) ;
-: 2451:extern void Add_error_string( int v1, const char * v2 ) ;
-: 2452:extern int Query_thread( void ) ;
-: 2453:extern void Close_port( const char * v1 ) ;
-: 2454:extern int Add_error_code( int v1 ) ;
-: 2455:extern void Free_mem( void * v1 ) ;
-: 2456:extern void Open_port( const Info &v1, char * v2 ) ;
-: 2457:extern bool Is_finalized( void ) ;
-: 2458:extern bool Is_thread_main( void ) ;
-: 2459:
-: 2460:#ifdef MPI_MODE_RDONLY
-: 2461:typedef int Datarep_extent_function( const Datatype&, Aint&, void *);
-: 2462:typedef int Datarep_conversion_function( void *, Datatype &, int, void *,
-: 2463: Offset, void * );
-: 2464:#endif
-: 2465:
-: 2466:
-: 2467:extern Datatype CHAR;
-: 2468:extern Datatype UNSIGNED_CHAR;
-: 2469:extern Datatype BYTE;
-: 2470:extern Datatype SHORT;
-: 2471:extern Datatype UNSIGNED_SHORT;
-: 2472:extern Datatype INT;
-: 2473:extern Datatype UNSIGNED;
-: 2474:extern Datatype LONG;
-: 2475:extern Datatype UNSIGNED_LONG;
-: 2476:extern Datatype FLOAT;
-: 2477:extern Datatype DOUBLE;
-: 2478:extern Datatype LONG_DOUBLE;
-: 2479:extern Datatype LONG_LONG_INT;
-: 2480:extern Datatype LONG_LONG;
-: 2481:extern Datatype PACKED;
-: 2482:extern Datatype LB;
-: 2483:extern Datatype UB;
-: 2484:extern Datatype FLOAT_INT;
-: 2485:extern Datatype DOUBLE_INT;
-: 2486:extern Datatype LONG_INT;
-: 2487:extern Datatype SHORT_INT;
-: 2488:extern Datatype LONG_DOUBLE_INT;
-: 2489:extern Datatype REAL4;
-: 2490:extern Datatype REAL8;
-: 2491:extern Datatype REAL16;
-: 2492:extern Datatype COMPLEX8;
-: 2493:extern Datatype COMPLEX16;
-: 2494:extern Datatype COMPLEX32;
-: 2495:extern Datatype INTEGER1;
-: 2496:extern Datatype INTEGER2;
-: 2497:extern Datatype INTEGER4;
-: 2498:extern Datatype INTEGER8;
-: 2499:extern Datatype INTEGER16;
-: 2500:extern Datatype WCHAR;
-: 2501:extern Datatype SIGNED_CHAR;
-: 2502:extern Datatype UNSIGNED_LONG_LONG;
-: 2503:extern Datatype TWOINT;
-: 2504:extern Datatype BOOL;
-: 2505:#define MPIR_CXX_BOOL 0x4c000133
-: 2506:extern Datatype COMPLEX;
-: 2507:#define MPIR_CXX_COMPLEX 0x4c000834
-: 2508:extern Datatype DOUBLE_COMPLEX;
-: 2509:#define MPIR_CXX_DOUBLE_COMPLEX 0x4c001035
-: 2510:extern Datatype LONG_DOUBLE_COMPLEX;
-: 2511:#define MPIR_CXX_LONG_DOUBLE_COMPLEX 0x4c001836
-: 2512:extern Datatype DATATYPE_NULL;
-: 2513:
-: 2514:#if 1
-: 2515:extern Datatype INTEGER;
-: 2516:extern Datatype REAL;
-: 2517:extern Datatype DOUBLE_PRECISION;
-: 2518:extern Datatype F_COMPLEX;
-: 2519:extern Datatype F_DOUBLE_COMPLEX;
-: 2520:extern Datatype LOGICAL;
-: 2521:extern Datatype CHARACTER;
-: 2522:extern Datatype TWOREAL;
-: 2523:extern Datatype TWODOUBLE_PRECISION;
-: 2524:extern Datatype TWOINTEGER;
-: 2525:#endif
-: 2526:extern const Op MAX;
-: 2527:extern const Op MIN;
-: 2528:extern const Op SUM;
-: 2529:extern const Op PROD;
-: 2530:extern const Op LAND;
-: 2531:extern const Op BAND;
-: 2532:extern const Op LOR;
-: 2533:extern const Op BOR;
-: 2534:extern const Op LXOR;
-: 2535:extern const Op BXOR;
-: 2536:extern const Op MINLOC;
-: 2537:extern const Op MAXLOC;
-: 2538:extern const Op REPLACE;
-: 2539:extern const Op OP_NULL;
-: 2540:extern Intracomm COMM_WORLD;
-: 2541:extern Intracomm COMM_SELF;
-: 2542:extern const Group GROUP_EMPTY;
-: 2543:extern const Nullcomm COMM_NULL;
-: 2544:extern const Group GROUP_NULL;
-: 2545:extern const Request REQUEST_NULL;
-: 2546:extern const Errhandler ERRHANDLER_NULL;
-: 2547:extern const Errhandler ERRORS_RETURN;
-: 2548:extern const Errhandler ERRORS_ARE_FATAL;
-: 2549:extern const Errhandler ERRORS_THROW_EXCEPTIONS;
-: 2550:extern const Info INFO_NULL;
-: 2551:extern const Win WIN_NULL;
-: 2552:extern File FILE_NULL;
-: 2553:extern const int BSEND_OVERHEAD;
-: 2554:extern const int KEYVAL_INVALID;
-: 2555:extern const int CART;
-: 2556:extern const int GRAPH;
-: 2557:extern const int IDENT;
-: 2558:extern const int SIMILAR;
-: 2559:extern const int CONGRUENT;
-: 2560:extern const int UNEQUAL;
-: 2561:extern const int PROC_NULL;
-: 2562:extern const int ANY_TAG;
-: 2563:extern const int ANY_SOURCE;
-: 2564:extern const int ROOT;
-: 2565:extern const int TAG_UB;
-: 2566:extern const int IO;
-: 2567:extern const int HOST;
-: 2568:extern const int WTIME_IS_GLOBAL;
-: 2569:extern const int UNIVERSE_SIZE;
-: 2570:extern const int LASTUSEDCODE;
-: 2571:extern const int APPNUM;
-: 2572:extern const int MAX_PROCESSOR_NAME;
-: 2573:extern const int MAX_ERROR_STRING;
-: 2574:extern const int MAX_PORT_NAME;
-: 2575:extern const int MAX_OBJECT_NAME;
-: 2576:extern const int MAX_INFO_VAL;
-: 2577:extern const int MAX_INFO_KEY;
-: 2578:extern const int UNDEFINED;
-: 2579:extern const int LOCK_EXCLUSIVE;
-: 2580:extern const int LOCK_SHARED;
-: 2581:extern const int WIN_BASE;
-: 2582:extern const int WIN_DISP_UNIT;
-: 2583:extern const int WIN_SIZE;
-: 2584:extern const int SUCCESS;
-: 2585:extern const int ERR_BUFFER;
-: 2586:extern const int ERR_COUNT;
-: 2587:extern const int ERR_TYPE;
-: 2588:extern const int ERR_TAG;
-: 2589:extern const int ERR_COMM;
-: 2590:extern const int ERR_RANK;
-: 2591:extern const int ERR_REQUEST;
-: 2592:extern const int ERR_ROOT;
-: 2593:extern const int ERR_GROUP;
-: 2594:extern const int ERR_OP;
-: 2595:extern const int ERR_TOPOLOGY;
-: 2596:extern const int ERR_DIMS;
-: 2597:extern const int ERR_ARG;
-: 2598:extern const int ERR_UNKNOWN;
-: 2599:extern const int ERR_TRUNCATE;
-: 2600:extern const int ERR_OTHER;
-: 2601:extern const int ERR_INTERN;
-: 2602:extern const int ERR_PENDING;
-: 2603:extern const int ERR_IN_STATUS;
-: 2604:extern const int ERR_LASTCODE;
-: 2605:extern const int ERR_FILE;
-: 2606:extern const int ERR_ACCESS;
-: 2607:extern const int ERR_AMODE;
-: 2608:extern const int ERR_BAD_FILE;
-: 2609:extern const int ERR_FILE_EXISTS;
-: 2610:extern const int ERR_FILE_IN_USE;
-: 2611:extern const int ERR_NO_SPACE;
-: 2612:extern const int ERR_NO_SUCH_FILE;
-: 2613:extern const int ERR_IO;
-: 2614:extern const int ERR_READ_ONLY;
-: 2615:extern const int ERR_CONVERSION;
-: 2616:extern const int ERR_DUP_DATAREP;
-: 2617:extern const int ERR_UNSUPPORTED_DATAREP;
-: 2618:extern const int ERR_INFO;
-: 2619:extern const int ERR_INFO_KEY;
-: 2620:extern const int ERR_INFO_VALUE;
-: 2621:extern const int ERR_INFO_NOKEY;
-: 2622:extern const int ERR_NAME;
-: 2623:extern const int ERR_NO_MEM;
-: 2624:extern const int ERR_NOT_SAME;
-: 2625:extern const int ERR_PORT;
-: 2626:extern const int ERR_QUOTA;
-: 2627:extern const int ERR_SERVICE;
-: 2628:extern const int ERR_SPAWN;
-: 2629:extern const int ERR_UNSUPPORTED_OPERATION;
-: 2630:extern const int ERR_WIN;
-: 2631:extern const int ERR_BASE;
-: 2632:extern const int ERR_LOCKTYPE;
-: 2633:extern const int ERR_KEYVAL;
-: 2634:extern const int ERR_RMA_CONFLICT;
-: 2635:extern const int ERR_RMA_SYNC;
-: 2636:extern const int ERR_SIZE;
-: 2637:extern const int ERR_DISP;
-: 2638:extern const int ERR_ASSERT;
-: 2639:extern const int TYPECLASS_REAL;
-: 2640:extern const int TYPECLASS_INTEGER;
-: 2641:extern const int TYPECLASS_COMPLEX;
-: 2642:#if defined(MPI_SEEK_SET) && !defined(MPICH_IGNORE_CXX_SEEK) && !defined(SEEK_SET)
-: 2643:extern const int SEEK_SET;
-: 2644:extern const int SEEK_END;
-: 2645:extern const int SEEK_CUR;
-: 2646:#endif
-: 2647:extern const int DISTRIBUTE_BLOCK;
-: 2648:extern const int DISTRIBUTE_CYCLIC;
-: 2649:extern const int DISTRIBUTE_DFLT_DARG;
-: 2650:extern const int DISTRIBUTE_NONE;
-: 2651:extern const int ORDER_C;
-: 2652:extern const int ORDER_FORTRAN;
-: 2653:// Include these only if MPI-IO is available
-: 2654:#ifdef MPI_MODE_RDONLY
-: 2655:extern const int MAX_DATAREP_STRING;
-: 2656:extern const MPI_Offset DISPLACEMENT_CURRENT;
-: 2657:extern const int MODE_APPEND;
-: 2658:extern const int MODE_CREATE;
-: 2659:extern const int MODE_DELETE_ON_CLOSE;
-: 2660:extern const int MODE_EXCL;
-: 2661:extern const int MODE_RDONLY;
-: 2662:extern const int MODE_RDWR;
-: 2663:extern const int MODE_SEQUENTIAL;
-: 2664:extern const int MODE_UNIQUE_OPEN;
-: 2665:extern const int MODE_WRONLY;
-: 2666:#endif // IO
-: 2667:extern const int MODE_NOCHECK;
-: 2668:extern const int MODE_NOPRECEDE;
-: 2669:extern const int MODE_NOPUT;
-: 2670:extern const int MODE_NOSTORE;
-: 2671:extern const int MODE_NOSUCCEED;
-: 2672:extern const int COMBINER_CONTIGUOUS;
-: 2673:extern const int COMBINER_DARRAY;
-: 2674:extern const int COMBINER_DUP;
-: 2675:extern const int COMBINER_F90_COMPLEX;
-: 2676:extern const int COMBINER_F90_INTEGER;
-: 2677:extern const int COMBINER_F90_REAL;
-: 2678:extern const int COMBINER_HINDEXED_INTEGER;
-: 2679:extern const int COMBINER_HINDEXED;
-: 2680:extern const int COMBINER_HVECTOR_INTEGER;
-: 2681:extern const int COMBINER_HVECTOR;
-: 2682:extern const int COMBINER_INDEXED_BLOCK;
-: 2683:extern const int COMBINER_INDEXED;
-: 2684:extern const int COMBINER_NAMED;
-: 2685:extern const int COMBINER_RESIZED;
-: 2686:extern const int COMBINER_STRUCT_INTEGER;
-: 2687:extern const int COMBINER_STRUCT;
-: 2688:extern const int COMBINER_SUBARRAY;
-: 2689:extern const int COMBINER_VECTOR;
-: 2690:extern const int THREAD_FUNNELED;
-: 2691:extern const int THREAD_MULTIPLE;
-: 2692:extern const int THREAD_SERIALIZED;
-: 2693:extern const int THREAD_SINGLE;
-: 2694:extern const char ** const ARGV_NULL;
-: 2695:extern const char *** const ARGVS_NULL;
-: 2696:extern void * const BOTTOM;
-: 2697:extern void * const IN_PLACE;
-: 2698:extern void Init(void);
-: 2699:extern void Init(int &, char **& );
-: 2700:extern int Init_thread(int);
-: 2701:extern int Init_thread(int &, char **&, int );
-: 2702:extern double Wtime(void);
-: 2703:extern double Wtick(void);
-: 2704:} // namespace MPI
|