1 /* -*- Mode: C; c-basic-offset:4 ; -*- */ 2 /* 3 * (C) 2001 by Argonne National Laboratory. 4 * See COPYRIGHT in top-level directory. 5 */ 6 #ifndef MPIERRS_H_INCLUDED 7 #define MPIERRS_H_INCLUDED 8 /* ------------------------------------------------------------------------- */ 9 /* mpierrs.h */ 10 /* ------------------------------------------------------------------------- */ 11 12 /* Error checking (see --enable-error-checking for control of this) */ 13 #ifdef HAVE_ERROR_CHECKING 14 15 #define MPID_ERROR_LEVEL_ALL 1 16 #define MPID_ERROR_LEVEL_RUNTIME 2 17 /* Use MPID_ERROR_DECL to wrap declarations that are needed only when 18 error checking is turned on */ 19 #define MPID_ERROR_DECL(a) a 20 21 #if HAVE_ERROR_CHECKING == MPID_ERROR_LEVEL_ALL 22 #define MPID_BEGIN_ERROR_CHECKS 23 #define MPID_END_ERROR_CHECKS 24 #define MPID_ELSE_ERROR_CHECKS 25 #elif HAVE_ERROR_CHECKING == MPID_ERROR_LEVEL_RUNTIME 26 #define MPID_BEGIN_ERROR_CHECKS if (MPIR_Process.do_error_checks) { 27 #define MPID_ELSE_ERROR_CHECKS }else{ 28 #define MPID_END_ERROR_CHECKS } 29 #else 30 #error "Unknown value for error checking" 31 #endif 32 33 #else 34 #define MPID_BEGIN_ERROR_CHECKS 35 #define MPID_END_ERROR_CHECKS 36 #define MPID_ERROR_DECL(a) 37 #endif /* HAVE_ERROR_CHECKING */ 38 39 /* 40 * Standardized error checking macros. These provide the correct tests for 41 * common tests. These set err with the encoded error value. 42 */ 43 #define MPIR_ERRTEST_SEND_TAG(tag,err) \ 44 if ((tag) < 0 || (tag) > MPIR_Process.attrs.tag_ub) { \ 45 err = MPIR_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, FCNAME, __LINE__, \ 46 MPI_ERR_TAG, "**tag", "**tag %d", tag); \ 47 goto fn_fail; \ 48 } 49 50 #define MPIR_ERRTEST_RECV_TAG(tag,err) \ 51 if ((tag) < MPI_ANY_TAG || (tag) > MPIR_Process.attrs.tag_ub) { \ 52 err = MPIR_Err_create_code( MPI_SUCCESS, MPIR_ERR_RECOVERABLE, FCNAME, __LINE__, \ 53 MPI_ERR_TAG, "**tag", "**tag %d", tag ); \ 54 goto fn_fail; \ 55 } 56 57 #define MPIR_ERRTEST_RANK(comm_ptr,rank,err) \ 58 if ((rank) < 0 || (rank) >= (comm_ptr)->remote_size) { \ 59 err = MPIR_Err_create_code( MPI_SUCCESS, MPIR_ERR_RECOVERABLE, FCNAME, __LINE__, \ 60 MPI_ERR_RANK, "**rank", "**rank %d %d", rank, \ 61 (comm_ptr)->remote_size ); \ 62 goto fn_fail; \ 63 } 64 65 #define MPIR_ERRTEST_SEND_RANK(comm_ptr,rank,err) \ 66 if ((rank) < MPI_PROC_NULL || (rank) >= (comm_ptr)->remote_size) { \ 67 err = MPIR_Err_create_code( MPI_SUCCESS, MPIR_ERR_RECOVERABLE, FCNAME, __LINE__, \ 68 MPI_ERR_RANK, "**rank", "**rank %d %d", rank, \ 69 (comm_ptr)->remote_size ); \ 70 goto fn_fail; \ 71 } 72 73 #define MPIR_ERRTEST_RECV_RANK(comm_ptr,rank,err) \ 74 if ((rank) < MPI_ANY_SOURCE || (rank) >= (comm_ptr)->remote_size) { \ 75 err = MPIR_Err_create_code( MPI_SUCCESS, MPIR_ERR_RECOVERABLE, FCNAME, __LINE__, \ 76 MPI_ERR_RANK, "**rank", "**rank %d %d", rank, \ 77 (comm_ptr)->remote_size ); \ 78 goto fn_fail; \ 79 } 80 81 #define MPIR_ERRTEST_COUNT(count,err) \ 82 if ((count) < 0) { \ 83 err = MPIR_Err_create_code(MPI_SUCCESS, \ 84 MPIR_ERR_RECOVERABLE, \ 85 FCNAME, __LINE__, \ 86 MPI_ERR_COUNT, \ 87 "**countneg", \ 88 "**countneg %d", \ 89 count ); \ 90 goto fn_fail; \ 91 } 92 93 #define MPIR_ERRTEST_DISP(disp,err) \ 94 if ((disp) < 0) { \ 95 err = MPIR_Err_create_code(MPI_SUCCESS, \ 96 MPIR_ERR_RECOVERABLE, \ 97 FCNAME, __LINE__, \ 98 MPI_ERR_DISP, \ 99 "**rmadisp", 0 ); \ 100 goto fn_fail; \ 101 } 102 103 #define MPIR_ERRTEST_ALIAS(ptr1,ptr2,err) \ 104 if ((ptr1)==(ptr2) && (ptr1) != MPI_BOTTOM) { \ 105 err = MPIR_Err_create_code(MPI_SUCCESS, \ 106 MPIR_ERR_RECOVERABLE, \ 107 FCNAME, __LINE__, \ 108 MPI_ERR_BUFFER, \ 109 "**bufalias", 0 ); \ 110 goto fn_fail; \ 111 } 112 113 /* FIXME this test is probably too broad. Comparing the (buffer,type,count) 114 * tuples is really what is needed to check for aliasing. */ 115 #define MPIR_ERRTEST_ALIAS_COLL(ptr1,ptr2,err) \ 116 if ((ptr1)==(ptr2)) { \ 117 err = MPIR_Err_create_code(MPI_SUCCESS, \ 118 MPIR_ERR_RECOVERABLE, \ 119 FCNAME, __LINE__, \ 120 MPI_ERR_BUFFER, \ 121 "**bufalias", 0 ); \ 122 goto fn_fail; \ 123 } 124 125 #define MPIR_ERRTEST_ARGNULL(arg,arg_name,err) \ 126 if (!(arg)) { \ 127 err = MPIR_Err_create_code(MPI_SUCCESS, \ 128 MPIR_ERR_RECOVERABLE, \ 129 FCNAME, __LINE__, \ 130 MPI_ERR_ARG, \ 131 "**nullptr", \ 132 "**nullptr %s", \ 133 arg_name ); \ 134 goto fn_fail; \ 135 } 136 137 #define MPIR_ERRTEST_ARGNEG(arg,arg_name,err) \ 138 if ((arg) < 0) { \ 139 err = MPIR_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, \ 140 FCNAME, __LINE__, MPI_ERR_ARG, \ 141 "**argneg", \ 142 "**argneg %s %d", arg_name, arg ); \ 143 goto fn_fail; \ 144 } 145 146 #define MPIR_ERRTEST_ARGNONPOS(arg,arg_name,err) \ 147 if ((arg) <= 0) { \ 148 err = MPIR_Err_create_code(MPI_SUCCESS, \ 149 MPIR_ERR_RECOVERABLE, \ 150 FCNAME, __LINE__, \ 151 MPI_ERR_ARG, \ 152 "**argnonpos", \ 153 "**argnonpos %s %d", \ 154 arg_name, arg ); \ 155 goto fn_fail; \ 156 } 157 158 /* An intracommunicator must have a root between 0 and local_size-1. */ 159 /* intercomm can be between MPI_PROC_NULL (or MPI_ROOT) and remote_size-1 */ 160 #define MPIR_ERRTEST_INTRA_ROOT(comm_ptr,root,err) \ 161 if ((root) < 0 || (root) >= (comm_ptr)->local_size) { \ 162 err = MPIR_Err_create_code( MPI_SUCCESS, MPIR_ERR_RECOVERABLE, FCNAME, __LINE__, \ 163 MPI_ERR_ROOT, "**root", "**root %d", root ); \ 164 goto fn_fail; \ 165 } 166 167 /* We use -2 (MPI_PROC_NULL and MPI_ROOT are negative) for the 168 intercomm test */ 169 #define MPIR_ERRTEST_INTER_ROOT(comm_ptr,root,err) \ 170 if ((root) < -3 || (root) >= (comm_ptr)->remote_size) { \ 171 err = MPIR_Err_create_code( MPI_SUCCESS, MPIR_ERR_RECOVERABLE, FCNAME, __LINE__, \ 172 MPI_ERR_ROOT, "**root", "**root %d", root ); \ 173 goto fn_fail; \ 174 } 175 176 #define MPIR_ERRTEST_PERSISTENT(reqp,err) \ 177 if ((reqp)->kind != MPID_PREQUEST_SEND && reqp->kind != MPID_PREQUEST_RECV) { \ 178 err = MPIR_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, FCNAME, __LINE__, \ 179 MPI_ERR_REQUEST, "**requestnotpersist", 0 ); \ 180 goto fn_fail; \ 181 } 182 183 #define MPIR_ERRTEST_PERSISTENT_ACTIVE(reqp,err) \ 184 if (((reqp)->kind == MPID_PREQUEST_SEND || \ 185 reqp->kind == MPID_PREQUEST_RECV) && reqp->partner_request != NULL) { \ 186 err = MPIR_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, FCNAME, __LINE__, \ 187 MPI_ERR_REQUEST, "**requestpersistactive", 0 ); \ 188 goto fn_fail; \ 189 } 190 191 #define MPIR_ERRTEST_COMM_INTRA(comm_ptr, err ) \ 192 if ((comm_ptr)->comm_kind != MPID_INTRACOMM) { \ 193 err = MPIR_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, FCNAME, __LINE__, \ 194 MPI_ERR_COMM,"**commnotintra",0); \ 195 goto fn_fail; \ 196 } 197 198 #define MPIR_ERRTEST_COMM_TAG(tag,err) \ 199 if ((tag) < 0 || (tag) > MPIR_Process.attrs.tag_ub) { \ 200 err = MPIR_Err_create_code( MPI_SUCCESS, MPIR_ERR_RECOVERABLE, FCNAME, __LINE__, \ 201 MPI_ERR_TAG, "**tag", "**tag %d", tag); \ 202 goto fn_fail; \ 203 } 204 205 /* Tests for totally meaningless datatypes first, then for 206 * MPI_DATATYPE_NULL as a separate case. 207 */ 208 #define MPIR_ERRTEST_DATATYPE(datatype, name_, err_) \ 209 { \ 210 if (HANDLE_GET_MPI_KIND(datatype) != MPID_DATATYPE || \ 211 (HANDLE_GET_KIND(datatype) == HANDLE_KIND_INVALID && \ 212 datatype != MPI_DATATYPE_NULL)) \ 213 { \ 214 err_ = MPIR_Err_create_code(MPI_SUCCESS, \ 215 MPIR_ERR_RECOVERABLE, \ 216 FCNAME, __LINE__, \ 217 MPI_ERR_TYPE, \ 218 "**dtype", 0 ); \ 219 goto fn_fail; \ 220 } \ 221 if (datatype == MPI_DATATYPE_NULL) \ 222 { \ 223 err_ = MPIR_Err_create_code(MPI_SUCCESS, \ 224 MPIR_ERR_RECOVERABLE, \ 225 FCNAME, __LINE__, \ 226 MPI_ERR_TYPE, \ 227 "**dtypenull", \ 228 "**dtypenull %s", \ 229 name_); \ 230 goto fn_fail; \ 231 } \ 232 } 233 234 #define MPIR_ERRTEST_TYPE_RMA_ATOMIC(datatype_, name_, err_) \ 235 do { \ 236 if (!MPIR_Type_is_rma_atomic(datatype_)) { \ 237 err_ = MPIR_Err_create_code(MPI_SUCCESS, \ 238 MPIR_ERR_RECOVERABLE, \ 239 FCNAME, __LINE__, \ 240 MPI_ERR_TYPE, \ 241 "**rmatypenotatomic", \ 242 "**rmatypenotatomic %D", \ 243 name_); \ 244 goto fn_fail; \ 245 } \ 246 } while (0) 247 248 #define MPIR_ERRTEST_SENDBUF_INPLACE(sendbuf,count,err) \ 249 if (count > 0 && sendbuf == MPI_IN_PLACE) { \ 250 err = MPIR_Err_create_code( MPI_SUCCESS, MPIR_ERR_RECOVERABLE, FCNAME, __LINE__, \ 251 MPI_ERR_BUFFER, "**sendbuf_inplace", 0 ); \ 252 goto fn_fail; \ 253 } 254 255 #define MPIR_ERRTEST_RECVBUF_INPLACE(recvbuf,count,err) \ 256 if (count > 0 && recvbuf == MPI_IN_PLACE) { \ 257 err = MPIR_Err_create_code( MPI_SUCCESS, MPIR_ERR_RECOVERABLE, FCNAME, __LINE__, \ 258 MPI_ERR_BUFFER, "**recvbuf_inplace", 0 ); \ 259 goto fn_fail; \ 260 } 261 262 #define MPIR_ERRTEST_BUF_INPLACE(buf,count,err) \ 263 if (count > 0 && buf == MPI_IN_PLACE) { \ 264 err = MPIR_Err_create_code( MPI_SUCCESS, MPIR_ERR_RECOVERABLE, FCNAME, __LINE__, \ 265 MPI_ERR_BUFFER, "**buf_inplace", 0 ); \ 266 goto fn_fail; \ 267 } 268 269 /* 270 * Check that the triple (buf,count,datatype) does not specify a null 271 * buffer. This does not guarantee that the buffer is valid but does 272 * catch the most common problems. 273 * Question: 274 * Should this be an (inlineable) routine? 275 * Since it involves extracting the datatype pointer for non-builtin 276 * datatypes, should it take a dtypeptr argument (valid only if not 277 * builtin)? 278 */ 279 #define MPIR_ERRTEST_USERBUFFER(buf,count,dtype,err) \ 280 if (count > 0 && buf == 0) { \ 281 int ferr = 0; \ 282 if (HANDLE_GET_KIND(dtype) == HANDLE_KIND_BUILTIN) { ferr=1; } \ 283 else { \ 284 int errsize; \ 285 MPID_Datatype *errdtypeptr; \ 286 MPID_Datatype_get_ptr(dtype,errdtypeptr); \ 287 MPID_Datatype_get_size_macro(dtype,errsize); \ 288 if (errdtypeptr && errdtypeptr->true_lb == 0 && \ 289 errsize > 0) { ferr=1; } \ 290 } \ 291 if (ferr) { \ 292 err = MPIR_Err_create_code(MPI_SUCCESS, \ 293 MPIR_ERR_RECOVERABLE, \ 294 FCNAME, __LINE__, \ 295 MPI_ERR_BUFFER, \ 296 "**bufnull", 0 ); \ 297 goto fn_fail; \ 298 } \ 299 } 300 301 /* The following are placeholders. We haven't decided yet whether these 302 should take a handle or pointer, or if they should take a handle and return 303 a pointer if the handle is valid. These need to be rationalized with the 304 MPID_xxx_valid_ptr and MPID_xxx_get_ptr. 305 306 [BRT] They should not take a handle and return a pointer if they will be 307 placed inside of a #ifdef HAVE_ERROR_CHECKING block. Personally, I think 308 the macros should take handles. We already have macros for validating 309 pointers to various objects. 310 */ 311 /* --BEGIN ERROR MACROS-- */ 312 #define MPIR_ERRTEST_VALID_HANDLE(handle_,kind_,err_,errclass_,gmsg_) { \ 313 if (HANDLE_GET_MPI_KIND(handle_) != kind_ || \ 314 HANDLE_GET_KIND(handle_) == HANDLE_KIND_INVALID) { \ 315 MPIU_ERR_SETANDSTMT(err_,errclass_,goto fn_fail,gmsg_); \ 316 } \ 317 } 318 /* --END ERROR MACROS-- */ 319 320 #define MPIR_ERRTEST_OP(op,err) \ 321 if (op == MPI_OP_NULL) { \ 322 MPIU_ERR_SETANDSTMT(err,MPI_ERR_OP,goto fn_fail,"**opnull"); \ 323 } \ 324 else { \ 325 MPIR_ERRTEST_VALID_HANDLE(op,MPID_OP,err,MPI_ERR_OP,"**op"); \ 326 } 327 328 #define MPIR_ERRTEST_GROUP(group,err) \ 329 if (group == MPI_GROUP_NULL) { \ 330 MPIU_ERR_SETANDSTMT(err,MPI_ERR_GROUP,goto fn_fail,"**groupnull"); \ 331 } \ 332 else { \ 333 MPIR_ERRTEST_VALID_HANDLE(group,MPID_GROUP,err,MPI_ERR_GROUP,"**group"); \ 334 } 335 336 #define MPIR_ERRTEST_COMM(comm_, err_) \ 337 { \ 338 if ((comm_) == MPI_COMM_NULL) \ 339 { \ 340 MPIU_ERR_SETANDSTMT((err_), MPI_ERR_COMM,goto fn_fail,"**commnull"); \ 341 } \ 342 else \ 343 { \ 344 MPIR_ERRTEST_VALID_HANDLE((comm_), MPID_COMM, (err_), MPI_ERR_COMM, "**comm"); \ 345 } \ 346 } 347 348 #define MPIR_ERRTEST_WIN(win_, err_) \ 349 { \ 350 if ((win_) == MPI_WIN_NULL) \ 351 { \ 352 MPIU_ERR_SETANDSTMT((err_), MPI_ERR_WIN,goto fn_fail, "**winnull"); \ 353 } \ 354 else \ 355 { \ 356 MPIR_ERRTEST_VALID_HANDLE((win_), MPID_WIN, (err_), MPI_ERR_WIN, "**win"); \ 357 } \ 358 } 359 360 #define MPIR_ERRTEST_REQUEST(request_, err_) \ 361 { \ 362 if ((request_) == MPI_REQUEST_NULL) \ 363 { \ 364 MPIU_ERR_SETANDSTMT((err_), MPI_ERR_REQUEST,goto fn_fail, "**requestnull"); \ 365 } \ 366 else \ 367 { \ 368 MPIR_ERRTEST_VALID_HANDLE((request_), MPID_REQUEST, (err_), MPI_ERR_REQUEST, "**request"); \ 369 } \ 370 } 371 372 #define MPIR_ERRTEST_REQUEST_OR_NULL(request_, err_) \ 373 { \ 374 if ((request_) != MPI_REQUEST_NULL) \ 375 { \ 376 MPIR_ERRTEST_VALID_HANDLE((request_), MPID_REQUEST, (err_), MPI_ERR_REQUEST, "**request"); \ 377 } \ 378 } 379 380 /* This macro does *NOT* jump to fn_fail - all uses check mpi_errno */ 381 #define MPIR_ERRTEST_ARRAYREQUEST_OR_NULL(request_, i_, err_) \ 382 { \ 383 if ((request_) != MPI_REQUEST_NULL) \ 384 { \ 385 if (HANDLE_GET_MPI_KIND(request_) != MPID_REQUEST) { \ 386 MPIU_ERR_SETANDSTMT2(err_,MPI_ERR_REQUEST,goto fn_fail, \ 387 "**request_invalid_kind","**request_invalid_kind %d %d", \ 388 i_, HANDLE_GET_MPI_KIND(request_)); \ 389 } \ 390 else if (HANDLE_GET_KIND(request_) == HANDLE_KIND_INVALID) { \ 391 MPIU_ERR_SETANDSTMT1(err_,MPI_ERR_REQUEST,goto fn_fail, \ 392 "**request","**request %d", i_ ); \ 393 } \ 394 } \ 395 } 396 397 #define MPIR_ERRTEST_ERRHANDLER(errhandler_,err_) \ 398 if (errhandler_ == MPI_ERRHANDLER_NULL) { \ 399 MPIU_ERR_SETANDSTMT(err_,MPI_ERR_ARG,goto fn_fail,"**errhandlernull"); \ 400 } \ 401 else { \ 402 MPIR_ERRTEST_VALID_HANDLE(errhandler_,MPID_ERRHANDLER, \ 403 err_,MPI_ERR_ARG,"**errhandler"); \ 404 } 405 406 #define MPIR_ERRTEST_INFO(info_, err_) \ 407 { \ 408 if ((info_) == MPI_INFO_NULL) \ 409 { \ 410 MPIU_ERR_SETANDSTMT(err_, MPI_ERR_ARG,goto fn_fail, "**infonull"); \ 411 } \ 412 else \ 413 { \ 414 MPIR_ERRTEST_VALID_HANDLE((info_), MPID_INFO, (err_), MPI_ERR_ARG, "**info"); \ 415 } \ 416 } 417 418 #define MPIR_ERRTEST_INFO_OR_NULL(info_, err_) \ 419 { \ 420 if ((info_) != MPI_INFO_NULL) \ 421 { \ 422 MPIR_ERRTEST_VALID_HANDLE((info_), MPID_INFO, (err_), MPI_ERR_ARG, "**info"); \ 423 } \ 424 } 425 426 #define MPIR_ERRTEST_KEYVAL(keyval_, object_, objectdesc_, err_) \ 427 { \ 428 if ((keyval_) == MPI_KEYVAL_INVALID) \ 429 { \ 430 MPIU_ERR_SETANDSTMT(err_, MPI_ERR_KEYVAL,goto fn_fail, "**keyvalinvalid"); \ 431 } \ 432 else if (HANDLE_GET_MPI_KIND(keyval_) != MPID_KEYVAL) \ 433 { \ 434 MPIU_ERR_SETANDSTMT(err_, MPI_ERR_KEYVAL,goto fn_fail, "**keyval"); \ 435 } \ 436 else if ((((keyval_) & 0x03c00000) >> 22) != (object_)) \ 437 { \ 438 MPIU_ERR_SETANDSTMT1(err_, MPI_ERR_KEYVAL,goto fn_fail, "**keyvalobj", \ 439 "**keyvalobj %s", (objectdesc_)); \ 440 } \ 441 } 442 443 #define MPIR_ERRTEST_KEYVAL_PERM(keyval_, err_) \ 444 { \ 445 if (HANDLE_GET_MPI_KIND(keyval_) == MPID_KEYVAL && \ 446 HANDLE_GET_KIND(keyval_) == HANDLE_KIND_BUILTIN) \ 447 { \ 448 MPIU_ERR_SETANDSTMT(err_, MPI_ERR_KEYVAL,goto fn_fail, "**permattr"); \ 449 } \ 450 } 451 452 /* some simple memcpy aliasing checks */ 453 #define MPIU_ERR_CHKMEMCPYANDSTMT(err_,stmt_,src_,dst_,len_) \ 454 MPIU_ERR_CHKANDSTMT3(MPIU_MEM_RANGES_OVERLAP((dst_),(len_),(src_),(len_)),err_,MPI_ERR_INTERN,stmt_,"**memcpyalias","**memcpyalias %p %p %L",(src_),(dst_),(long long)(len_)) 455 #define MPIU_ERR_CHKMEMCPYANDJUMP(err_,src_,dst_,len_) \ 456 MPIU_ERR_CHKMEMCPYANDSTMT((err_),goto fn_fail,(src_),(dst_),(len_)) 457 458 /* Special MPI error "class/code" for out of memory */ 459 /* FIXME: not yet done */ 460 #define MPIR_ERR_MEMALLOCFAILED MPI_ERR_INTERN 461 462 /* 463 * Standardized error setting and checking macros 464 * These are intended to simplify the insertion of standardized error 465 * checks 466 * 467 */ 468 /* --BEGIN ERROR MACROS-- */ 469 #define MPIU_ERR_POP(err_) \ 470 MPIU_ERR_SETANDSTMT(err_,MPI_ERR_OTHER,goto fn_fail,"**fail") 471 #define MPIU_ERR_POP_LABEL(err_, label_) \ 472 MPIU_ERR_SETANDSTMT(err_,MPI_ERR_OTHER,goto label_,"**fail") 473 #define MPIU_ERR_POPFATAL(err_) \ 474 MPIU_ERR_SETFATALANDSTMT(err_,MPI_ERR_OTHER,goto fn_fail,"**fail") 475 #define MPIU_ERR_POPFATAL_LABEL(err_, label_) \ 476 MPIU_ERR_SETFATALANDSTMT(err_,MPI_ERR_OTHER,goto label_,"**fail") 477 478 /* If you add any macros to this list, make sure that you update 479 maint/extracterrmsgs to handle the additional macros (see the hash 480 KnownErrRoutines in that script) 481 ERR_SETSIMPLE is like ERR_SET except that it just sets the error, it 482 doesn't add it to an existing error. This is appropriate in cases 483 where there can be no pre-existing error, and MPI_SUCCESS is needed for the 484 first argument to MPIR_Err_create_code . 485 */ 486 #ifdef HAVE_ERROR_CHECKING 487 #define MPIU_ERR_SETSIMPLE(err_,class_,msg_) \ 488 err_ = MPIR_Err_create_code( MPI_SUCCESS,MPIR_ERR_RECOVERABLE,FCNAME,\ 489 __LINE__, class_, msg_, 0 ) 490 #define MPIU_ERR_SET(err_,class_,msg_) \ 491 err_ = MPIR_Err_create_code( err_,MPIR_ERR_RECOVERABLE,FCNAME,\ 492 __LINE__, class_, msg_, 0 ) 493 #define MPIU_ERR_SET1(err_,class_,gmsg_,smsg_,arg1_) \ 494 err_ = MPIR_Err_create_code( err_,MPIR_ERR_RECOVERABLE,FCNAME,\ 495 __LINE__, class_, gmsg_, smsg_, arg1_ ) 496 #define MPIU_ERR_SET2(err_,class_,gmsg_,smsg_,arg1_,arg2_) \ 497 err_ = MPIR_Err_create_code( err_,MPIR_ERR_RECOVERABLE,FCNAME,\ 498 __LINE__, class_, gmsg_, smsg_, arg1_, arg2_ ) 499 #define MPIU_ERR_SETANDSTMT(err_,class_,stmt_,msg_) \ 500 do {err_ = MPIR_Err_create_code( err_,MPIR_ERR_RECOVERABLE,FCNAME,\ 501 __LINE__, class_, msg_, 0 ); stmt_ ;} while (0) 502 #define MPIU_ERR_SETANDSTMT1(err_,class_,stmt_,gmsg_,smsg_,arg1_) \ 503 do {err_ = MPIR_Err_create_code( err_,MPIR_ERR_RECOVERABLE,FCNAME,\ 504 __LINE__, class_, gmsg_, smsg_, arg1_ ); stmt_ ;} while (0) 505 #define MPIU_ERR_SETANDSTMT2(err_,class_,stmt_,gmsg_,smsg_,arg1_,arg2_) \ 506 do {err_ = MPIR_Err_create_code( err_,MPIR_ERR_RECOVERABLE,FCNAME,\ 507 __LINE__, class_, gmsg_, smsg_, arg1_, arg2_ ); stmt_ ;} while (0) 508 #define MPIU_ERR_SETANDSTMT3(err_,class_,stmt_,gmsg_,smsg_,arg1_,arg2_, arg3_) \ 509 do {err_ = MPIR_Err_create_code( err_,MPIR_ERR_RECOVERABLE,FCNAME,\ 510 __LINE__, class_, gmsg_, smsg_, arg1_, arg2_, arg3_ ); stmt_ ;} while (0) 511 #define MPIU_ERR_SETANDSTMT4(err_,class_,stmt_,gmsg_,smsg_,arg1_,arg2_, arg3_, arg4_) \ 512 do {err_ = MPIR_Err_create_code( err_,MPIR_ERR_RECOVERABLE,FCNAME,\ 513 __LINE__, class_, gmsg_, smsg_, arg1_, arg2_, arg3_, arg4_ ); stmt_ ;} while (0) 514 515 #define MPIU_ERR_SETFATALSIMPLE(err_,class_,msg_) \ 516 err_ = MPIR_Err_create_code( MPI_SUCCESS,MPIR_ERR_FATAL,FCNAME, \ 517 __LINE__, class_, msg_, 0 ) 518 #define MPIU_ERR_SETFATAL(err_,class_,msg_) \ 519 err_ = MPIR_Err_create_code( err_,MPIR_ERR_FATAL,FCNAME,\ 520 __LINE__, class_, msg_, 0 ) 521 #define MPIU_ERR_SETFATAL1(err_,class_,gmsg_,smsg_,arg1_) \ 522 err_ = MPIR_Err_create_code( err_,MPIR_ERR_FATAL,FCNAME,\ 523 __LINE__, class_, gmsg_, smsg_, arg1_ ) 524 #define MPIU_ERR_SETFATAL2(err_,class_,gmsg_,smsg_,arg1_,arg2_) \ 525 err_ = MPIR_Err_create_code( err_,MPIR_ERR_FATAL,FCNAME,\ 526 __LINE__, class_, gmsg_, smsg_, arg1_, arg2_ ) 527 #define MPIU_ERR_SETFATALANDSTMT(err_,class_,stmt_,msg_) \ 528 do {err_ = MPIR_Err_create_code( err_,MPIR_ERR_FATAL,FCNAME,\ 529 __LINE__, class_, msg_, 0 ); stmt_ ;} while (0) 530 #define MPIU_ERR_SETFATALANDSTMT1(err_,class_,stmt_,gmsg_,smsg_,arg1_) \ 531 do {err_ = MPIR_Err_create_code( err_,MPIR_ERR_FATAL,FCNAME,\ 532 __LINE__, class_, gmsg_, smsg_, arg1_ ); stmt_ ;} while (0) 533 #define MPIU_ERR_SETFATALANDSTMT2(err_,class_,stmt_,gmsg_,smsg_,arg1_,arg2_) \ 534 do {err_ = MPIR_Err_create_code( err_,MPIR_ERR_FATAL,FCNAME,\ 535 __LINE__, class_, gmsg_, smsg_, arg1_, arg2_ ); stmt_ ;} while (0) 536 #define MPIU_ERR_SETFATALANDSTMT3(err_,class_,stmt_,gmsg_,smsg_,arg1_,arg2_, arg3_) \ 537 do {err_ = MPIR_Err_create_code( err_,MPIR_ERR_FATAL,FCNAME,\ 538 __LINE__, class_, gmsg_, smsg_, arg1_, arg2_, arg3_ ); stmt_ ;} while (0) 539 #define MPIU_ERR_SETFATALANDSTMT4(err_,class_,stmt_,gmsg_,smsg_,arg1_,arg2_, arg3_, arg4_) \ 540 do {err_ = MPIR_Err_create_code( err_,MPIR_ERR_FATAL,FCNAME,\ 541 __LINE__, class_, gmsg_, smsg_, arg1_, arg2_, arg3_, arg4_ ); stmt_ ;} while (0) 542 #define MPIU_ERR_ADD(err_, newerr_) \ 543 do {(err_) = MPIR_Err_combine_codes((err_), (newerr_));} while (0) 544 #else 545 /* Simply set the class, being careful not to override a previously 546 set class. */ 547 #define MPIU_ERR_SETSIMPLE(err_,class_,msg_) \ 548 do {err_ = class_;} while (0) 549 #define MPIU_ERR_SET(err_,class_,msg_) \ 550 do {if (!err_){err_=class_;}} while (0) 551 #define MPIU_ERR_SET1(err_,class_,gmsg_,smsg_,arg1_) \ 552 MPIU_ERR_SET(err_,class_,msg_) 553 #define MPIU_ERR_SET2(err_,class_,gmsg_,smsg_,arg1_,arg2_) \ 554 MPIU_ERR_SET(err_,class_,msg_) 555 #define MPIU_ERR_SETANDSTMT(err_,class_,stmt_,msg_) \ 556 do {if (!err_){err_=class_;} stmt_;} while (0) 557 #define MPIU_ERR_SETANDSTMT1(err_,class_,stmt_,gmsg_,smsg_,arg1_) \ 558 MPIU_ERR_SETANDSTMT(err_,class_,stmt_,gmsg_) 559 #define MPIU_ERR_SETANDSTMT2(err_,class_,stmt_,gmsg_,smsg_,arg1_,arg2_) \ 560 MPIU_ERR_SETANDSTMT(err_,class_,stmt_,gmsg_) 561 #define MPIU_ERR_SETANDSTMT3(err_,class_,stmt_,gmsg_,smsg_,arg1_,arg2_,arg3_) \ 562 MPIU_ERR_SETANDSTMT(err_,class_,stmt_,gmsg_) 563 #define MPIU_ERR_SETANDSTMT4(err_,class_,stmt_,gmsg_,smsg_,arg1_,arg2_,arg3_,arg4_) \ 564 MPIU_ERR_SETANDSTMT(err_,class_,stmt_,gmsg_) 565 566 #define MPIU_ERR_SETFATALSIMPLE(err_,class_,msg_) \ 567 do {err_ = class_;} while (0) 568 #define MPIU_ERR_SETFATAL(err_,class_,msg_) \ 569 do {if (!err_){err_=class_;}} while (0) 570 #define MPIU_ERR_SETFATAL1(err_,class_,gmsg_,smsg_,arg1_) \ 571 MPIU_ERR_SET(err_,class_,msg_) 572 #define MPIU_ERR_SETFATAL2(err_,class_,gmsg_,smsg_,arg1_,arg2_) \ 573 MPIU_ERR_SET(err_,class_,msg_) 574 #define MPIU_ERR_SETFATALANDSTMT(err_,class_,stmt_,msg_) \ 575 MPIU_ERR_SETANDSTMT(err_,class_,stmt_,msg_) 576 #define MPIU_ERR_SETFATALANDSTMT1(err_,class_,stmt_,gmsg_,smsg_,arg1_) \ 577 MPIU_ERR_SETANDSTMT(err_,class_,stmt_,gmsg_) 578 #define MPIU_ERR_SETFATALANDSTMT2(err_,class_,stmt_,gmsg_,smsg_,arg1_,arg2_) \ 579 MPIU_ERR_SETANDSTMT(err_,class_,stmt_,gmsg_) 580 #define MPIU_ERR_SETFATALANDSTMT3(err_,class_,stmt_,gmsg_,smsg_,arg1_,arg2_,arg3_) \ 581 MPIU_ERR_SETANDSTMT(err_,class_,stmt_,gmsg_) 582 #define MPIU_ERR_SETFATALANDSTMT4(err_,class_,stmt_,gmsg_,smsg_,arg1_,arg2_,arg3_,arg4_) \ 583 MPIU_ERR_SETANDSTMT(err_,class_,stmt_,gmsg_) 584 /* No-op - use original error class; discard newerr_ unless err is 585 MPI_SUCCESS*/ 586 #define MPIU_ERR_ADD(err_, newerr_) \ 587 do {if (!err_) err_ = newerr_;} while (0) 588 #endif 589 590 /* The following definitions are the same independent of the choice of 591 HAVE_ERROR_CHECKING */ 592 #define MPIU_ERR_SETANDJUMP(err_,class_,msg_) \ 593 MPIU_ERR_SETANDSTMT(err_,class_,goto fn_fail,msg_) 594 #define MPIU_ERR_SETFATALANDJUMP(err_,class_,msg_) \ 595 MPIU_ERR_SETFATALANDSTMT(err_,class_,goto fn_fail,msg_) 596 #define MPIU_ERR_CHKANDSTMT(cond_,err_,class_,stmt_,msg_) \ 597 do {if (cond_) { MPIU_ERR_SETANDSTMT(err_,class_,stmt_,msg_); }} while (0) 598 #define MPIU_ERR_CHKFATALANDSTMT(cond_,err_,class_,stmt_,msg_) \ 599 do {if (cond_) { MPIU_ERR_SETFATALANDSTMT(err_,class_,stmt_,msg_); }} while (0) 600 #define MPIU_ERR_CHKANDJUMP(cond_,err_,class_,msg_) \ 601 MPIU_ERR_CHKANDSTMT(cond_,err_,class_,goto fn_fail,msg_) 602 #define MPIU_ERR_CHKFATALANDJUMP(cond_,err_,class_,msg_) \ 603 MPIU_ERR_CHKFATALANDSTMT(cond_,err_,class_,goto fn_fail,msg_) 604 605 #define MPIU_ERR_SETANDJUMP1(err_,class_,gmsg_,smsg_,arg1_) \ 606 MPIU_ERR_SETANDSTMT1(err_,class_,goto fn_fail,gmsg_,smsg_,arg1_) 607 #define MPIU_ERR_SETFATALANDJUMP1(err_,class_,gmsg_,smsg_,arg1_) \ 608 MPIU_ERR_SETFATALANDSTMT1(err_,class_,goto fn_fail,gmsg_,smsg_,arg1_) 609 #define MPIU_ERR_CHKANDSTMT1(cond_,err_,class_,stmt_,gmsg_,smsg_,arg1_) \ 610 do {if (cond_) { MPIU_ERR_SETANDSTMT1(err_,class_,stmt_,gmsg_,smsg_,arg1_); }} while (0) 611 #define MPIU_ERR_CHKFATALANDSTMT1(cond_,err_,class_,stmt_,gmsg_,smsg_,arg1_) \ 612 do {if (cond_) { MPIU_ERR_SETFATALANDSTMT1(err_,class_,stmt_,gmsg_,smsg_,arg1_); }} while (0) 613 #define MPIU_ERR_CHKANDJUMP1(cond_,err_,class_,gmsg_,smsg_,arg1_) \ 614 MPIU_ERR_CHKANDSTMT1(cond_,err_,class_,goto fn_fail,gmsg_,smsg_,arg1_) 615 #define MPIU_ERR_CHKFATALANDJUMP1(cond_,err_,class_,gmsg_,smsg_,arg1_) \ 616 MPIU_ERR_CHKFATALANDSTMT1(cond_,err_,class_,goto fn_fail,gmsg_,smsg_,arg1_) 617 618 #define MPIU_ERR_SETANDJUMP2(err_,class_,gmsg_,smsg_,arg1_,arg2_) \ 619 MPIU_ERR_SETANDSTMT2(err_,class_,goto fn_fail,gmsg_,smsg_,arg1_,arg2_) 620 #define MPIU_ERR_SETFATALANDJUMP2(err_,class_,gmsg_,smsg_,arg1_,arg2_) \ 621 MPIU_ERR_SETFATALANDSTMT2(err_,class_,goto fn_fail,gmsg_,smsg_,arg1_,arg2_) 622 #define MPIU_ERR_CHKANDSTMT2(cond_,err_,class_,stmt_,gmsg_,smsg_,arg1_,arg2_) \ 623 do {if (cond_) { MPIU_ERR_SETANDSTMT2(err_,class_,stmt_,gmsg_,smsg_,arg1_,arg2_); }} while (0) 624 #define MPIU_ERR_CHKFATALANDSTMT2(cond_,err_,class_,stmt_,gmsg_,smsg_,arg1_,arg2_) \ 625 do {if (cond_) { MPIU_ERR_SETFATALANDSTMT2(err_,class_,stmt_,gmsg_,smsg_,arg1_,arg2_); }} while (0) 626 #define MPIU_ERR_CHKANDJUMP2(cond_,err_,class_,gmsg_,smsg_,arg1_,arg2_) \ 627 MPIU_ERR_CHKANDSTMT2(cond_,err_,class_,goto fn_fail,gmsg_,smsg_,arg1_,arg2_) 628 #define MPIU_ERR_CHKFATALANDJUMP2(cond_,err_,class_,gmsg_,smsg_,arg1_,arg2_) \ 629 MPIU_ERR_CHKFATALANDSTMT2(cond_,err_,class_,goto fn_fail,gmsg_,smsg_,arg1_,arg2_) 630 631 #define MPIU_ERR_SETANDJUMP3(err_,class_,gmsg_,smsg_,arg1_,arg2_,arg3_) \ 632 MPIU_ERR_SETANDSTMT3(err_,class_,goto fn_fail,gmsg_,smsg_,arg1_,arg2_,arg3_) 633 #define MPIU_ERR_SETFATALANDJUMP3(err_,class_,gmsg_,smsg_,arg1_,arg2_,arg3_) \ 634 MPIU_ERR_SETFATALANDSTMT3(err_,class_,goto fn_fail,gmsg_,smsg_,arg1_,arg2_,arg3_) 635 #define MPIU_ERR_CHKANDSTMT3(cond_,err_,class_,stmt_,gmsg_,smsg_,arg1_,arg2_,arg3_) \ 636 do {if (cond_) { MPIU_ERR_SETANDSTMT3(err_,class_,stmt_,gmsg_,smsg_,arg1_,arg2_,arg3_); }} while (0) 637 #define MPIU_ERR_CHKFATALANDSTMT3(cond_,err_,class_,stmt_,gmsg_,smsg_,arg1_,arg2_,arg3_) \ 638 do {if (cond_) { MPIU_ERR_SETFATALANDSTMT3(err_,class_,stmt_,gmsg_,smsg_,arg1_,arg2_,arg3_); }} while (0) 639 #define MPIU_ERR_CHKANDJUMP3(cond_,err_,class_,gmsg_,smsg_,arg1_,arg2_,arg3_) \ 640 MPIU_ERR_CHKANDSTMT3(cond_,err_,class_,goto fn_fail,gmsg_,smsg_,arg1_,arg2_,arg3_) 641 #define MPIU_ERR_CHKFATALANDJUMP3(cond_,err_,class_,gmsg_,smsg_,arg1_,arg2_,arg3_) \ 642 MPIU_ERR_CHKFATALANDSTMT3(cond_,err_,class_,goto fn_fail,gmsg_,smsg_,arg1_,arg2_,arg3_) 643 644 #define MPIU_ERR_SETANDJUMP4(err_,class_,gmsg_,smsg_,arg1_,arg2_,arg3_,arg4_) \ 645 MPIU_ERR_SETANDSTMT4(err_,class_,goto fn_fail,gmsg_,smsg_,arg1_,arg2_,arg3_,arg4_) 646 #define MPIU_ERR_SETFATALANDJUMP4(err_,class_,gmsg_,smsg_,arg1_,arg2_,arg3_,arg4_) \ 647 MPIU_ERR_SETFATALANDSTMT4(err_,class_,goto fn_fail,gmsg_,smsg_,arg1_,arg2_,arg3_,arg4_) 648 #define MPIU_ERR_CHKANDSTMT4(cond_,err_,class_,stmt_,gmsg_,smsg_,arg1_,arg2_,arg3_, arg4_) \ 649 do {if (cond_) { MPIU_ERR_SETANDSTMT4(err_,class_,stmt_,gmsg_,smsg_,arg1_,arg2_,arg3_,arg4_); }} while (0) 650 #define MPIU_ERR_CHKFATALANDSTMT4(cond_,err_,class_,stmt_,gmsg_,smsg_,arg1_,arg2_,arg3_, arg4_) \ 651 do {if (cond_) { MPIU_ERR_SETFATALANDSTMT4(err_,class_,stmt_,gmsg_,smsg_,arg1_,arg2_,arg3_,arg4_); }} while (0) 652 #define MPIU_ERR_CHKANDJUMP4(cond_,err_,class_,gmsg_,smsg_,arg1_,arg2_,arg3_,arg4_) \ 653 MPIU_ERR_CHKANDSTMT4(cond_,err_,class_,goto fn_fail,gmsg_,smsg_,arg1_,arg2_,arg3_,arg4_) 654 #define MPIU_ERR_CHKFATALANDJUMP4(cond_,err_,class_,gmsg_,smsg_,arg1_,arg2_,arg3_,arg4_) \ 655 MPIU_ERR_CHKFATALANDSTMT4(cond_,err_,class_,goto fn_fail,gmsg_,smsg_,arg1_,arg2_,arg3_,arg4_) 656 657 #define MPIU_ERR_INTERNAL(err_, msg_) \ 658 MPIU_ERR_SETFATAL1(err_, MPI_ERR_INTERN, "**intern", "**intern %s", msg_) 659 #define MPIU_ERR_INTERNALANDSTMT(err_, msg_, stmt_) \ 660 MPIU_ERR_SETANDSTMT1(err_, MPI_ERR_INTERN, stmt_, "**intern", "**intern %s", msg_) 661 #define MPIU_ERR_INTERNALANDJUMP(err_, msg_) \ 662 MPIU_ERR_INTERNALANDSTMT(err_, msg_, goto fn_fail) 663 #define MPIU_ERR_CHKINTERNAL(cond_, err_, msg_) \ 664 do {if (cond_) MPIU_ERR_INTERNALANDJUMP(err_, msg_);} while(0) 665 666 /* --END ERROR MACROS-- */ 667 668 /* 669 * Special case for "is initialized". 670 * This should be used in cases where there is no 671 * additional error checking 672 */ 673 #ifdef HAVE_ERROR_CHECKING 674 #define MPIR_ERRTEST_INITIALIZED_ORDIE() \ 675 do { \ 676 if (MPIR_Process.initialized != MPICH_WITHIN_MPI) \ 677 { \ 678 MPIR_Err_preOrPostInit(); \ 679 } \ 680 } while (0) 681 #else 682 #define MPIR_ERRTEST_INITIALIZED_ORDIE() do {} while (0) 683 #endif 684 685 /* ------------------------------------------------------------------------- */ 686 /* end of mpierrs.h */ 687 /* ------------------------------------------------------------------------- */ 688 689 #endif 690