Uncovered lines in src/mpi/romio/adio/ad_nfs/ad_nfs_read.c.gcov 18: -: 13: ADIO_Offset offset, ADIO_Status *status, int *error_code) 19: function ADIOI_NFS_ReadContig called 0 returned 0% blocks executed 0% 20: #####: 14:{ 21: #####: 15: int err=-1, datatype_size, len; 22: -: 16: static char myname[] = "ADIOI_NFS_READCONTIG"; 23: -: 17: 24: #####: 18: MPI_Type_size(datatype, &datatype_size); 25: call 0 never executed 26: #####: 19: len = datatype_size * count; 27: -: 20: 28: #####: 21: if (file_ptr_type == ADIO_EXPLICIT_OFFSET) { 29: branch 0 never executed 30: branch 1 never executed 31: #####: 22: if (fd->fp_sys_posn != offset) { 35: -: 24: MPE_Log_event( ADIOI_MPE_lseek_a, 0, NULL ); 36: -: 25:#endif 37: #####: 26: lseek(fd->fd_sys, offset, SEEK_SET); 41: -: 29:#endif 42: -: 30: } 43: #####: 31: if (fd->atomicity) 44: branch 0 never executed 45: branch 1 never executed 46: #####: 32: ADIOI_WRITE_LOCK(fd, offset, SEEK_SET, len); 47: call 0 never executed 48: #####: 33: else ADIOI_READ_LOCK(fd, offset, SEEK_SET, len); 51: -: 35: MPE_Log_event( ADIOI_MPE_read_a, 0, NULL ); 52: -: 36:#endif 53: #####: 37: err = read(fd->fd_sys, buf, len); 56: -: 39: MPE_Log_event( ADIOI_MPE_read_b, 0, NULL ); 57: -: 40:#endif 58: #####: 41: ADIOI_UNLOCK(fd, offset, SEEK_SET, len); 59: call 0 never executed 60: #####: 42: fd->fp_sys_posn = offset + err; 62: -: 44: } 63: -: 45: else { /* read from curr. location of ind. file pointer */ 64: #####: 46: offset = fd->fp_ind; 65: #####: 47: if (fd->fp_sys_posn != fd->fp_ind) { 69: -: 49: MPE_Log_event( ADIOI_MPE_lseek_a, 0, NULL ); 70: -: 50:#endif 71: #####: 51: lseek(fd->fd_sys, fd->fp_ind, SEEK_SET); 75: -: 54:#endif 76: -: 55: } 77: #####: 56: if (fd->atomicity) 78: branch 0 never executed 79: branch 1 never executed 80: #####: 57: ADIOI_WRITE_LOCK(fd, offset, SEEK_SET, len); 81: call 0 never executed 82: #####: 58: else ADIOI_READ_LOCK(fd, offset, SEEK_SET, len); 85: -: 60: MPE_Log_event( ADIOI_MPE_read_a, 0, NULL ); 86: -: 61:#endif 87: #####: 62: err = read(fd->fd_sys, buf, len); 90: -: 64: MPE_Log_event( ADIOI_MPE_read_b, 0, NULL ); 91: -: 65:#endif 92: #####: 66: ADIOI_UNLOCK(fd, offset, SEEK_SET, len); 93: call 0 never executed 94: #####: 67: fd->fp_ind += err; 95: #####: 68: fd->fp_sys_posn = fd->fp_ind; 111: -: 79: 112: -: 80:#ifdef HAVE_STATUS_SET_BYTES 113: #####: 81: MPIR_Status_set_bytes(status, datatype, err); 115: -: 82:#endif 116: -: 83: 117: #####: 84: *error_code = MPI_SUCCESS; 198: -: 165: *error_code) 199: function ADIOI_NFS_ReadStrided called 0 returned 0% blocks executed 0% 200: #####: 166:{ 202: -: 168: 203: -: 169: ADIOI_Flatlist_node *flat_buf, *flat_file; 204: #####: 170: int i, j, k, err=-1, brd_size, frd_size=0, st_index=0; 205: -: 171: int bufsize, num, size, sum, n_etypes_in_filetype, size_in_filetype; 206: -: 172: int n_filetypes, etype_in_filetype; 207: #####: 173: ADIO_Offset abs_off_in_filetype=0; 210: -: 176: int buf_count, buftype_is_contig, filetype_is_contig; 211: -: 177: ADIO_Offset userbuf_off; 212: #####: 178: ADIO_Offset off, req_off, disp, end_offset=0, readbuf_off, start_off; 213: -: 179: char *readbuf, *tmp_buf, *value; 214: -: 180: int flag, st_frd_size, st_n_filetypes, readbuf_len; 215: #####: 181: int new_brd_size, new_frd_size, err_flag=0, info_flag, max_bufsize; 217: -: 183: static char myname[] = "ADIOI_NFS_READSTRIDED"; 218: -: 184: 219: #####: 185: ADIOI_Datatype_iscontig(datatype, &buftype_is_contig); 220: call 0 never executed 221: #####: 186: ADIOI_Datatype_iscontig(fd->filetype, &filetype_is_contig); 222: call 0 never executed 223: -: 187: 224: #####: 188: MPI_Type_size(fd->filetype, &filetype_size); 225: call 0 never executed 226: #####: 189: if ( ! filetype_size ) { 227: branch 0 never executed 228: branch 1 never executed 229: #####: 190: *error_code = MPI_SUCCESS; 230: #####: 191: return; 231: -: 192: } 232: -: 193: 233: #####: 194: MPI_Type_extent(fd->filetype, &filetype_extent); 234: call 0 never executed 235: #####: 195: MPI_Type_size(datatype, &buftype_size); 236: call 0 never executed 237: #####: 196: MPI_Type_extent(datatype, &buftype_extent); 238: call 0 never executed 239: #####: 197: etype_size = fd->etype_size; 240: -: 198: 241: #####: 199: bufsize = buftype_size * count; 243: -: 201:/* get max_bufsize from the info object. */ 244: -: 202: 245: #####: 203: value = (char *) ADIOI_Malloc((MPI_MAX_INFO_VAL+1)*sizeof(char)); 246: call 0 never executed 247: #####: 204: MPI_Info_get(fd->info, "ind_rd_buffer_size", MPI_MAX_INFO_VAL, value, 248: call 0 never executed 249: -: 205: &info_flag); 250: #####: 206: max_bufsize = atoi(value); 251: call 0 never executed 252: #####: 207: ADIOI_Free(value); 253: call 0 never executed 254: -: 208: 255: #####: 209: if (!buftype_is_contig && filetype_is_contig) { 261: -: 211:/* noncontiguous in memory, contiguous in file. */ 262: -: 212: 263: #####: 213: ADIOI_Flatten_datatype(datatype); 264: call 0 never executed 265: #####: 214: flat_buf = ADIOI_Flatlist; 266: #####: 215: while (flat_buf->type != datatype) flat_buf = flat_buf->next; 268: branch 1 never executed 269: -: 216: 270: #####: 217: off = (file_ptr_type == ADIO_INDIVIDUAL) ? fd->fp_ind : 273: -: 218: fd->disp + etype_size * offset; 274: -: 219: 275: #####: 220: start_off = off; 276: #####: 221: end_offset = off + bufsize - 1; 277: #####: 222: readbuf_off = off; 278: #####: 223: readbuf = (char *) ADIOI_Malloc(max_bufsize); 279: call 0 never executed 280: #####: 224: readbuf_len = (int) (ADIOI_MIN(max_bufsize, end_offset-readbuf_off+1)); 281: -: 225: 282: -: 226:/* if atomicity is true, lock (exclusive) the region to be accessed */ 283: #####: 227: if (fd->atomicity) 284: branch 0 never executed 285: branch 1 never executed 286: #####: 228: ADIOI_WRITE_LOCK(fd, start_off, SEEK_SET, end_offset-start_off+1); 290: -: 231: MPE_Log_event( ADIOI_MPE_lseek_a, 0, NULL ); 291: -: 232:#endif 292: #####: 233: lseek(fd->fd_sys, readbuf_off, SEEK_SET); 295: -: 235: MPE_Log_event( ADIOI_MPE_lseek_b, 0, NULL ); 296: -: 236:#endif 297: #####: 237: if (!(fd->atomicity)) ADIOI_READ_LOCK(fd, readbuf_off, SEEK_SET, readbuf_len); 302: -: 239: MPE_Log_event( ADIOI_MPE_read_a, 0, NULL ); 303: -: 240:#endif 304: #####: 241: err = read(fd->fd_sys, readbuf, readbuf_len); 307: -: 243: MPE_Log_event( ADIOI_MPE_read_b, 0, NULL ); 308: -: 244:#endif 309: #####: 245: if (!(fd->atomicity)) ADIOI_UNLOCK(fd, readbuf_off, SEEK_SET, readbuf_len); 311: branch 1 never executed 312: call 2 never executed 313: #####: 246: if (err == -1) err_flag = 1; 315: branch 1 never executed 316: -: 247: 317: #####: 248: for (j=0; jcount; i++) { 321: branch 0 never executed 322: branch 1 never executed 323: #####: 250: userbuf_off = j*buftype_extent + flat_buf->indices[i]; 324: #####: 251: req_off = off; 325: #####: 252: req_len = flat_buf->blocklens[i]; 326: #####: 253: ADIOI_BUFFERED_READ 356: branch 29 never executed 357: call 30 never executed 358: #####: 254: off += flat_buf->blocklens[i]; 359: -: 255: } 360: -: 256: 361: #####: 257: if (fd->atomicity) 362: branch 0 never executed 363: branch 1 never executed 364: #####: 258: ADIOI_UNLOCK(fd, start_off, SEEK_SET, end_offset-start_off+1); 365: call 0 never executed 366: -: 259: 367: #####: 260: if (file_ptr_type == ADIO_INDIVIDUAL) fd->fp_ind = off; 369: branch 1 never executed 370: -: 261: 371: #####: 262: ADIOI_Free(readbuf); /* malloced in the buffered_read macro */ 372: call 0 never executed 373: -: 263: 374: #####: 264: if (err_flag) { 375: branch 0 never executed 376: branch 1 never executed 377: #####: 265: *error_code = MPIO_Err_create_code(MPI_SUCCESS, 383: -: 268: "**io %s", strerror(errno)); 384: -: 269: } 385: #####: 270: else *error_code = MPI_SUCCESS; 389: -: 274: 390: -: 275:/* filetype already flattened in ADIO_Open */ 391: #####: 276: flat_file = ADIOI_Flatlist; 392: #####: 277: while (flat_file->type != fd->filetype) flat_file = flat_file->next; 393: branch 0 never executed 394: branch 1 never executed 395: #####: 278: disp = fd->disp; 396: -: 279: 397: #####: 280: if (file_ptr_type == ADIO_INDIVIDUAL) { 399: branch 1 never executed 400: -: 281: /* Wei-keng reworked type processing to be a bit more efficient */ 401: #####: 282: offset = fd->fp_ind - disp; 402: #####: 283: n_filetypes = (offset - flat_file->indices[0]) / filetype_extent; 403: #####: 284: offset -= (ADIO_Offset)n_filetypes * filetype_extent; 405: -: 286: 406: -: 287: /* find the block where offset is located, skip blocklens[i]==0 */ 407: #####: 288: for (i=0; icount; i++) { 409: branch 1 never executed 410: -: 289: ADIO_Offset dist; 411: #####: 290: if (flat_file->blocklens[i] == 0) continue; 412: branch 0 never executed 413: branch 1 never executed 414: #####: 291: dist = flat_file->indices[i] + flat_file->blocklens[i] - offset; 415: -: 292: /* frd_size is from offset to the end of block i */ 416: #####: 293: if (dist == 0) { 417: branch 0 never executed 418: branch 1 never executed 419: #####: 294: i++; 420: #####: 295: offset = flat_file->indices[i]; 421: #####: 296: frd_size = flat_file->blocklens[i]; 422: #####: 297: break; 423: -: 298: } 424: #####: 299: if (dist > 0 ) { 425: branch 0 never executed 426: branch 1 never executed 427: #####: 300: frd_size = dist; 428: #####: 301: break; 429: -: 302: } 430: -: 303: } 431: #####: 304: st_index = i; /* starting index in flat_file->indices[] */ 432: #####: 305: offset += disp + (ADIO_Offset)n_filetypes*filetype_extent; 433: -: 306: } 434: -: 307: else { 435: #####: 308: n_etypes_in_filetype = filetype_size/etype_size; 436: #####: 309: n_filetypes = (int) (offset / n_etypes_in_filetype); 437: #####: 310: etype_in_filetype = (int) (offset % n_etypes_in_filetype); 438: #####: 311: size_in_filetype = etype_in_filetype * etype_size; 439: -: 312: 440: #####: 313: sum = 0; 441: #####: 314: for (i=0; icount; i++) { 442: branch 0 never executed 443: branch 1 never executed 444: #####: 315: sum += flat_file->blocklens[i]; 445: #####: 316: if (sum > size_in_filetype) { 446: branch 0 never executed 447: branch 1 never executed 448: #####: 317: st_index = i; 449: #####: 318: frd_size = sum - size_in_filetype; 450: #####: 319: abs_off_in_filetype = flat_file->indices[i] + 451: -: 320: size_in_filetype - (sum - flat_file->blocklens[i]); 452: #####: 321: break; 455: -: 324: 456: -: 325: /* abs. offset in bytes in the file */ 457: #####: 326: offset = disp + (ADIO_Offset) n_filetypes*filetype_extent + 459: -: 328: } 460: -: 329: 461: #####: 330: start_off = offset; 464: -: 333: * block e.g. with subarray types that actually describe the whole 465: -: 334: * array */ 466: #####: 335: if (buftype_is_contig && bufsize <= frd_size) { 467: branch 0 never executed 468: branch 1 never executed 469: #####: 336: ADIO_ReadContig(fd, buf, bufsize, MPI_BYTE, ADIO_EXPLICIT_OFFSET, 471: -: 337: offset, status, error_code); 472: -: 338: 473: #####: 339: if (file_ptr_type == ADIO_INDIVIDUAL) { 476: -: 340: /* update MPI-IO file pointer to point to the first byte that 477: -: 341: * can be accessed in the fileview. */ 478: #####: 342: fd->fp_ind = offset + bufsize; 479: #####: 343: if (bufsize == frd_size) { 481: branch 1 never executed 482: -: 344: do { 483: #####: 345: st_index++; 484: #####: 346: if (st_index == flat_file->count) { 485: branch 0 never executed 486: branch 1 never executed 487: #####: 347: st_index = 0; 488: #####: 348: n_filetypes++; 489: -: 349: } 490: #####: 350: } while (flat_file->blocklens[st_index] == 0); 491: branch 0 never executed 492: branch 1 never executed 493: #####: 351: fd->fp_ind = disp + flat_file->indices[st_index] 495: -: 353: } 496: -: 354: } 497: #####: 355: fd->fp_sys_posn = -1; /* set it to null. */ 498: -: 356:#ifdef HAVE_STATUS_SET_BYTES 499: #####: 357: MPIR_Status_set_bytes(status, datatype, bufsize); 500: call 0 never executed 501: -: 358:#endif 502: #####: 359: return; 506: -: 363: e.g., if start_offset=0 and 100 bytes to be read, end_offset=99*/ 507: -: 364: 508: #####: 365: st_frd_size = frd_size; 509: #####: 366: st_n_filetypes = n_filetypes; 510: #####: 367: i = 0; 511: #####: 368: j = st_index; 512: #####: 369: off = offset; 513: #####: 370: frd_size = ADIOI_MIN(st_frd_size, bufsize); 514: #####: 371: while (i < bufsize) { 515: branch 0 never executed 516: branch 1 never executed 517: #####: 372: i += frd_size; 518: #####: 373: end_offset = off + frd_size - 1; 519: #####: 374: j = (j+1) % flat_file->count; 520: #####: 375: n_filetypes += (j == 0) ? 1 : 0; 521: #####: 376: while (flat_file->blocklens[j]==0) { 522: branch 0 never executed 523: branch 1 never executed 524: #####: 377: j = (j+1) % flat_file->count; 525: #####: 378: n_filetypes += (j == 0) ? 1 : 0; 526: -: 379: } 527: -: 380: 528: #####: 381: off = disp + flat_file->indices[j] + (ADIO_Offset) n_filetypes*filetype_extent; 529: #####: 382: frd_size = ADIOI_MIN(flat_file->blocklens[j], bufsize-i); 531: -: 384: 532: -: 385:/* if atomicity is true, lock (exclusive) the region to be accessed */ 533: #####: 386: if (fd->atomicity) 534: branch 0 never executed 535: branch 1 never executed 536: #####: 387: ADIOI_WRITE_LOCK(fd, start_off, SEEK_SET, end_offset-start_off+1); 538: -: 388: 539: -: 389: /* initial read into readbuf */ 540: #####: 390: readbuf_off = offset; 541: #####: 391: readbuf = (char *) ADIOI_Malloc(max_bufsize); 542: call 0 never executed 543: #####: 392: readbuf_len = (int) (ADIOI_MIN(max_bufsize, end_offset-readbuf_off+1)); 546: -: 395: MPE_Log_event( ADIOI_MPE_lseek_a, 0, NULL ); 547: -: 396:#endif 548: #####: 397: lseek(fd->fd_sys, offset, SEEK_SET); 551: -: 399: MPE_Log_event( ADIOI_MPE_lseek_b, 0, NULL ); 552: -: 400:#endif 553: #####: 401: if (!(fd->atomicity)) ADIOI_READ_LOCK(fd, offset, SEEK_SET, readbuf_len); 558: -: 403: MPE_Log_event( ADIOI_MPE_read_a, 0, NULL ); 559: -: 404:#endif 560: #####: 405: err = read(fd->fd_sys, readbuf, readbuf_len); 563: -: 407: MPE_Log_event( ADIOI_MPE_read_b, 0, NULL ); 564: -: 408:#endif 565: #####: 409: if (!(fd->atomicity)) ADIOI_UNLOCK(fd, offset, SEEK_SET, readbuf_len); 568: call 2 never executed 569: -: 410: 570: #####: 411: if (err == -1) err_flag = 1; 572: branch 1 never executed 573: -: 412: 574: #####: 413: if (buftype_is_contig && !filetype_is_contig) { 581: -: 416: common case. */ 582: -: 417: 583: #####: 418: i = 0; 584: #####: 419: j = st_index; 585: #####: 420: off = offset; 586: #####: 421: n_filetypes = st_n_filetypes; 587: #####: 422: frd_size = ADIOI_MIN(st_frd_size, bufsize); 588: #####: 423: while (i < bufsize) { 589: branch 0 never executed 590: branch 1 never executed 591: #####: 424: if (frd_size) { 597: -: 428: err = read(fd->fd_sys, ((char *) buf) + i, frd_size);*/ 598: -: 429: 599: #####: 430: req_off = off; 600: #####: 431: req_len = frd_size; 601: #####: 432: userbuf_off = i; 602: #####: 433: ADIOI_BUFFERED_READ 633: call 30 never executed 634: -: 434: } 635: #####: 435: i += frd_size; 636: -: 436: 637: #####: 437: if (off + frd_size < disp + flat_file->indices[j] + 639: branch 1 never executed 640: -: 438: flat_file->blocklens[j] + (ADIO_Offset) n_filetypes*filetype_extent) 641: #####: 439: off += frd_size; 643: -: 441: no more I/O needed. off is incremented by frd_size. */ 644: -: 442: else { 645: #####: 443: j = (j+1) % flat_file->count; 646: #####: 444: n_filetypes += (j == 0) ? 1 : 0; 647: #####: 445: while (flat_file->blocklens[j]==0) { 648: branch 0 never executed 649: branch 1 never executed 650: #####: 446: j = (j+1) % flat_file->count; 651: #####: 447: n_filetypes += (j == 0) ? 1 : 0; 652: -: 448: } 653: #####: 449: off = disp + flat_file->indices[j] + 654: -: 450: (ADIO_Offset) n_filetypes*filetype_extent; 655: #####: 451: frd_size = ADIOI_MIN(flat_file->blocklens[j], bufsize-i); 660: -: 456:/* noncontiguous in memory as well as in file */ 661: -: 457: 662: #####: 458: ADIOI_Flatten_datatype(datatype); 663: call 0 never executed 664: #####: 459: flat_buf = ADIOI_Flatlist; 665: #####: 460: while (flat_buf->type != datatype) flat_buf = flat_buf->next; 667: branch 1 never executed 668: -: 461: 669: #####: 462: k = num = buf_count = 0; 670: #####: 463: i = (int) (flat_buf->indices[0]); 671: #####: 464: j = st_index; 672: #####: 465: off = offset; 673: #####: 466: n_filetypes = st_n_filetypes; 674: #####: 467: frd_size = st_frd_size; 675: #####: 468: brd_size = flat_buf->blocklens[0]; 676: -: 469: 677: #####: 470: while (num < bufsize) { 678: branch 0 never executed 679: branch 1 never executed 680: #####: 471: size = ADIOI_MIN(frd_size, brd_size); 681: #####: 472: if (size) { 685: -: 474: err = read(fd->fd_sys, ((char *) buf) + i, size); */ 686: -: 475: 687: #####: 476: req_off = off; 688: #####: 477: req_len = size; 689: #####: 478: userbuf_off = i; 690: #####: 479: ADIOI_BUFFERED_READ 722: -: 480: } 723: -: 481: 724: #####: 482: new_frd_size = frd_size; 725: #####: 483: new_brd_size = brd_size; 726: -: 484: 727: #####: 485: if (size == frd_size) { 729: branch 1 never executed 730: -: 486:/* reached end of contiguous block in file */ 731: #####: 487: j = (j+1) % flat_file->count; 732: #####: 488: n_filetypes += (j == 0) ? 1 : 0; 733: #####: 489: while (flat_file->blocklens[j]==0) { 734: branch 0 never executed 735: branch 1 never executed 736: #####: 490: j = (j+1) % flat_file->count; 737: #####: 491: n_filetypes += (j == 0) ? 1 : 0; 738: -: 492: } 739: #####: 493: off = disp + flat_file->indices[j] + 740: -: 494: (ADIO_Offset) n_filetypes*filetype_extent; 741: -: 495: 742: #####: 496: new_frd_size = flat_file->blocklens[j]; 743: #####: 497: if (size != brd_size) { 744: branch 0 never executed 745: branch 1 never executed 746: #####: 498: i += size; 747: #####: 499: new_brd_size -= size; 749: -: 501: } 750: -: 502: 751: #####: 503: if (size == brd_size) { 754: -: 504:/* reached end of contiguous block in memory */ 755: -: 505: 756: #####: 506: k = (k + 1)%flat_buf->count; 757: #####: 507: buf_count++; 758: #####: 508: i = (int) (buftype_extent*(buf_count/flat_buf->count) + 759: -: 509: flat_buf->indices[k]); 760: #####: 510: new_brd_size = flat_buf->blocklens[k]; 761: #####: 511: if (size != frd_size) { 762: branch 0 never executed 763: branch 1 never executed 764: #####: 512: off += size; 765: #####: 513: new_frd_size -= size; 766: -: 514: } 767: -: 515: } 768: #####: 516: num += size; 769: #####: 517: frd_size = new_frd_size; 770: #####: 518: brd_size = new_brd_size; 772: -: 520: } 773: -: 521: 774: #####: 522: if (fd->atomicity) 775: branch 0 never executed 776: branch 1 never executed 777: #####: 523: ADIOI_UNLOCK(fd, start_off, SEEK_SET, end_offset-start_off+1); 778: call 0 never executed 779: -: 524: 780: #####: 525: if (file_ptr_type == ADIO_INDIVIDUAL) fd->fp_ind = off; 782: branch 1 never executed 783: -: 526: 784: #####: 527: ADIOI_Free(readbuf); /* malloced in the buffered_read macro */ 785: call 0 never executed 786: -: 528: 787: #####: 529: if (err_flag) { 788: branch 0 never executed 789: branch 1 never executed 790: #####: 530: *error_code = MPIO_Err_create_code(MPI_SUCCESS, 796: -: 533: "**io %s", strerror(errno)); 797: -: 534: } 798: #####: 535: else *error_code = MPI_SUCCESS; 799: -: 536: } 800: -: 537: 801: #####: 538: fd->fp_sys_posn = -1; /* set it to null. */ 802: -: 539: 803: -: 540:#ifdef HAVE_STATUS_SET_BYTES 804: #####: 541: MPIR_Status_set_bytes(status, datatype, bufsize); 809: -: 545:#endif 810: -: 546: 811: #####: 547: if (!buftype_is_contig) ADIOI_Delete_flattened(datatype); 223 line(s) not covered by tests in src/mpi/romio/adio/ad_nfs/ad_nfs_read.c.gcov Uncovered lines in src/mpi/romio/adio/ad_nfs/stdlib.h.gcov 289: -: 284:__NTH (atoi (__const char *__nptr)) 290: function atoi called 0 returned 0% blocks executed 0% 291: #####: 285:{ 292: #####: 286: return (int) strtol (__nptr, (char **) NULL, 10); 2 line(s) not covered by tests in src/mpi/romio/adio/ad_nfs/stdlib.h.gcov Uncovered lines in src/mpi/romio/adio/ad_nfs/ad_nfs_open.c.gcov 15: -: 10:void ADIOI_NFS_Open(ADIO_File fd, int *error_code) 16: function ADIOI_NFS_Open called 0 returned 0% blocks executed 0% 17: #####: 11:{ 20: -: 14: static char myname[] = "ADIOI_NFS_OPEN"; 21: -: 15: 22: #####: 16: if (fd->perm == ADIO_PERM_NULL) { 23: branch 0 never executed 24: branch 1 never executed 25: #####: 17: old_mask = umask(022); 26: call 0 never executed 27: #####: 18: umask(old_mask); 28: call 0 never executed 29: #####: 19: perm = old_mask ^ 0666; 30: -: 20: } 31: #####: 21: else perm = fd->perm; 32: -: 22: 33: #####: 23: amode = 0; 34: #####: 24: if (fd->access_mode & ADIO_CREATE) 35: branch 0 never executed 36: branch 1 never executed 37: #####: 25: amode = amode | O_CREAT; 38: #####: 26: if (fd->access_mode & ADIO_RDONLY) 39: branch 0 never executed 40: branch 1 never executed 41: #####: 27: amode = amode | O_RDONLY; 42: #####: 28: if (fd->access_mode & ADIO_WRONLY) 43: branch 0 never executed 44: branch 1 never executed 45: #####: 29: amode = amode | O_WRONLY; 46: #####: 30: if (fd->access_mode & ADIO_RDWR) 47: branch 0 never executed 48: branch 1 never executed 49: #####: 31: amode = amode | O_RDWR; 50: #####: 32: if (fd->access_mode & ADIO_EXCL) 51: branch 0 never executed 52: branch 1 never executed 53: #####: 33: amode = amode | O_EXCL; 56: -: 36: MPE_Log_event( ADIOI_MPE_open_a, 0, NULL ); 57: -: 37:#endif 58: #####: 38: fd->fd_sys = open(fd->filename, amode, perm); 61: -: 40: MPE_Log_event( ADIOI_MPE_open_b, 0, NULL ); 62: -: 41:#endif 63: #####: 42: fd->fd_direct = -1; 64: -: 43: 65: #####: 44: if ((fd->fd_sys != -1) && (fd->access_mode & ADIO_APPEND)) { 71: -: 46: MPE_Log_event( ADIOI_MPE_lseek_a, 0, NULL ); 72: -: 47:#endif 73: #####: 48: fd->fp_ind = fd->fp_sys_posn = lseek(fd->fd_sys, 0, SEEK_END); 78: -: 52: } 79: -: 53: 80: #####: 54: if (fd->fd_sys == -1) { 83: -: 55: /* Check for special error codes for those MPI error 84: -: 56: classes that relate to particular problems */ 85: #####: 57: if (errno == ENAMETOOLONG) 87: branch 1 never executed 88: branch 2 never executed 89: #####: 58: *error_code = MPIO_Err_create_code(MPI_SUCCESS, 96: -: 63: fd->filename, 97: -: 64: strlen(fd->filename)); 98: #####: 65: else if (errno == ENOENT) 100: branch 1 never executed 101: branch 2 never executed 102: #####: 66: *error_code = MPIO_Err_create_code(MPI_SUCCESS, 107: -: 70: "**filenoexist %s", 108: -: 71: fd->filename); 109: #####: 72: else if (errno == ENOTDIR || errno == ELOOP) 111: branch 1 never executed 112: branch 2 never executed 113: #####: 73: *error_code = MPIO_Err_create_code(MPI_SUCCESS, 118: -: 77: "**filenamedir %s", 119: -: 78: fd->filename); 120: #####: 79: else if (errno == EACCES) { 122: branch 1 never executed 123: branch 2 never executed 124: #####: 80: *error_code = MPIO_Err_create_code(MPI_SUCCESS, 130: -: 85: fd->filename); 131: -: 86: } 132: #####: 87: else if (errno == EROFS) { 135: branch 2 never executed 136: -: 88: /* Read only file or file system and write access requested */ 137: #####: 89: *error_code = MPIO_Err_create_code(MPI_SUCCESS, 142: -: 93: } 143: -: 94: else { 144: #####: 95: *error_code = MPIO_Err_create_code(MPI_SUCCESS, 151: -: 99: } 152: -: 100: } 153: #####: 101: else *error_code = MPI_SUCCESS; 34 line(s) not covered by tests in src/mpi/romio/adio/ad_nfs/ad_nfs_open.c.gcov Uncovered lines in src/mpi/romio/adio/ad_nfs/ad_nfs_write.c.gcov 18: -: 13: ADIO_Offset offset, ADIO_Status *status, int *error_code) 19: function ADIOI_NFS_WriteContig called 0 returned 0% blocks executed 0% 20: #####: 14:{ 21: #####: 15: int err=-1, datatype_size, len; 22: -: 16: static char myname[] = "ADIOI_NFS_WRITECONTIG"; 23: -: 17: 24: #####: 18: MPI_Type_size(datatype, &datatype_size); 25: call 0 never executed 26: #####: 19: len = datatype_size * count; 27: -: 20: 28: #####: 21: if (file_ptr_type == ADIO_EXPLICIT_OFFSET) { 29: branch 0 never executed 30: branch 1 never executed 31: #####: 22: if (fd->fp_sys_posn != offset) { 35: -: 24: MPE_Log_event( ADIOI_MPE_lseek_a, 0, NULL ); 36: -: 25:#endif 37: #####: 26: lseek(fd->fd_sys, offset, SEEK_SET); 41: -: 29:#endif 42: -: 30: } 43: #####: 31: ADIOI_WRITE_LOCK(fd, offset, SEEK_SET, len); 46: -: 33: MPE_Log_event( ADIOI_MPE_write_a, 0, NULL ); 47: -: 34:#endif 48: #####: 35: err = write(fd->fd_sys, buf, len); 51: -: 37: MPE_Log_event( ADIOI_MPE_write_b, 0, NULL ); 52: -: 38:#endif 53: #####: 39: ADIOI_UNLOCK(fd, offset, SEEK_SET, len); 54: call 0 never executed 55: #####: 40: fd->fp_sys_posn = offset + err; 57: -: 42: } 58: -: 43: else { /* write from curr. location of ind. file pointer */ 59: #####: 44: offset = fd->fp_ind; 60: #####: 45: if (fd->fp_sys_posn != fd->fp_ind) { 64: -: 47: MPE_Log_event( ADIOI_MPE_lseek_a, 0, NULL ); 65: -: 48:#endif 66: #####: 49: lseek(fd->fd_sys, fd->fp_ind, SEEK_SET); 70: -: 52:#endif 71: -: 53: } 72: #####: 54: ADIOI_WRITE_LOCK(fd, offset, SEEK_SET, len); 75: -: 56: MPE_Log_event( ADIOI_MPE_write_a, 0, NULL ); 76: -: 57:#endif 77: #####: 58: err = write(fd->fd_sys, buf, len); 80: -: 60: MPE_Log_event( ADIOI_MPE_write_b, 0, NULL ); 81: -: 61:#endif 82: #####: 62: ADIOI_UNLOCK(fd, offset, SEEK_SET, len); 83: call 0 never executed 84: #####: 63: fd->fp_ind += err; 85: #####: 64: fd->fp_sys_posn = fd->fp_ind; 102: -: 76: 103: -: 77:#ifdef HAVE_STATUS_SET_BYTES 104: #####: 78: MPIR_Status_set_bytes(status, datatype, err); 106: -: 79:#endif 107: -: 80: 108: #####: 81: *error_code = MPI_SUCCESS; 296: -: 269: *error_code) 297: function ADIOI_NFS_WriteStrided called 0 returned 0% blocks executed 0% 298: #####: 270:{ 300: -: 272: 301: -: 273: ADIOI_Flatlist_node *flat_buf, *flat_file; 302: #####: 274: int i, j, k, err=-1, bwr_size, fwr_size=0, st_index=0; 303: -: 275: int bufsize, num, size, sum, n_etypes_in_filetype, size_in_filetype; 304: -: 276: int n_filetypes, etype_in_filetype; 305: #####: 277: ADIO_Offset abs_off_in_filetype=0; 308: -: 280: int buf_count, buftype_is_contig, filetype_is_contig; 309: -: 281: ADIO_Offset userbuf_off; 310: #####: 282: ADIO_Offset off, req_off, disp, end_offset=0, writebuf_off, start_off; 311: -: 283: char *writebuf, *value; 312: -: 284: int flag, st_fwr_size, st_n_filetypes, writebuf_len, write_sz; 313: #####: 285: int new_bwr_size, new_fwr_size, err_flag=0, info_flag, max_bufsize; 314: -: 286: static char myname[] = "ADIOI_NFS_WRITESTRIDED"; 315: -: 287: 316: #####: 288: ADIOI_Datatype_iscontig(datatype, &buftype_is_contig); 317: call 0 never executed 318: #####: 289: ADIOI_Datatype_iscontig(fd->filetype, &filetype_is_contig); 319: call 0 never executed 320: -: 290: 321: #####: 291: MPI_Type_size(fd->filetype, &filetype_size); 322: call 0 never executed 323: #####: 292: if ( ! filetype_size ) { 324: branch 0 never executed 325: branch 1 never executed 326: #####: 293: *error_code = MPI_SUCCESS; 327: #####: 294: return; 328: -: 295: } 329: -: 296: 330: #####: 297: MPI_Type_extent(fd->filetype, &filetype_extent); 331: call 0 never executed 332: #####: 298: MPI_Type_size(datatype, &buftype_size); 333: call 0 never executed 334: #####: 299: MPI_Type_extent(datatype, &buftype_extent); 335: call 0 never executed 336: #####: 300: etype_size = fd->etype_size; 337: -: 301: 338: #####: 302: bufsize = buftype_size * count; 340: -: 304:/* get max_bufsize from the info object. */ 341: -: 305: 342: #####: 306: value = (char *) ADIOI_Malloc((MPI_MAX_INFO_VAL+1)*sizeof(char)); 343: call 0 never executed 344: #####: 307: MPI_Info_get(fd->info, "ind_wr_buffer_size", MPI_MAX_INFO_VAL, value, 345: call 0 never executed 346: -: 308: &info_flag); 347: #####: 309: max_bufsize = atoi(value); 348: call 0 never executed 349: #####: 310: ADIOI_Free(value); 350: call 0 never executed 351: -: 311: 352: #####: 312: if (!buftype_is_contig && filetype_is_contig) { 358: -: 314:/* noncontiguous in memory, contiguous in file. */ 359: -: 315: 360: #####: 316: ADIOI_Flatten_datatype(datatype); 361: call 0 never executed 362: #####: 317: flat_buf = ADIOI_Flatlist; 363: #####: 318: while (flat_buf->type != datatype) flat_buf = flat_buf->next; 365: branch 1 never executed 366: -: 319: 367: #####: 320: off = (file_ptr_type == ADIO_INDIVIDUAL) ? fd->fp_ind : 370: -: 321: fd->disp + etype_size * offset; 371: -: 322: 372: #####: 323: start_off = off; 373: #####: 324: end_offset = off + bufsize - 1; 374: #####: 325: writebuf_off = off; 375: #####: 326: writebuf = (char *) ADIOI_Malloc(max_bufsize); 376: call 0 never executed 377: #####: 327: writebuf_len = (int) (ADIOI_MIN(max_bufsize,end_offset-writebuf_off+1)); 378: -: 328: 379: -: 329:/* if atomicity is true, lock the region to be accessed */ 380: #####: 330: if (fd->atomicity) 381: branch 0 never executed 382: branch 1 never executed 383: #####: 331: ADIOI_WRITE_LOCK(fd, start_off, SEEK_SET, end_offset-start_off+1); 384: call 0 never executed 385: -: 332: 386: #####: 333: for (j=0; jcount; i++) { 390: branch 0 never executed 391: branch 1 never executed 392: #####: 335: userbuf_off = j*buftype_extent + flat_buf->indices[i]; 393: #####: 336: req_off = off; 394: #####: 337: req_len = flat_buf->blocklens[i]; 395: #####: 338: ADIOI_BUFFERED_WRITE_WITHOUT_READ 420: branch 24 never executed 421: branch 25 never executed 422: #####: 339: off += flat_buf->blocklens[i]; 427: -: 344: MPE_Log_event( ADIOI_MPE_lseek_a, 0, NULL ); 428: -: 345:#endif 429: #####: 346: lseek(fd->fd_sys, writebuf_off, SEEK_SET); 432: -: 348: MPE_Log_event( ADIOI_MPE_lseek_b, 0, NULL ); 433: -: 349:#endif 434: #####: 350: if (!(fd->atomicity)) ADIOI_WRITE_LOCK(fd, writebuf_off, SEEK_SET, writebuf_len); 439: -: 352: MPE_Log_event( ADIOI_MPE_write_a, 0, NULL ); 440: -: 353:#endif 441: #####: 354: err = write(fd->fd_sys, writebuf, writebuf_len); 444: -: 356: MPE_Log_event( ADIOI_MPE_write_b, 0, NULL ); 445: -: 357:#endif 446: #####: 358: if (!(fd->atomicity)) ADIOI_UNLOCK(fd, writebuf_off, SEEK_SET, writebuf_len); 448: branch 1 never executed 449: call 2 never executed 450: #####: 359: if (err == -1) err_flag = 1; 452: branch 1 never executed 453: -: 360: 454: #####: 361: if (fd->atomicity) 455: branch 0 never executed 456: branch 1 never executed 457: #####: 362: ADIOI_UNLOCK(fd, start_off, SEEK_SET, end_offset-start_off+1); 458: call 0 never executed 459: -: 363: 460: #####: 364: ADIOI_Free(writebuf); /* malloced in the buffered_write macro */ 461: call 0 never executed 462: -: 365: 463: #####: 366: if (file_ptr_type == ADIO_INDIVIDUAL) fd->fp_ind = off; 464: branch 0 never executed 465: branch 1 never executed 466: #####: 367: if (err_flag) { 467: branch 0 never executed 468: branch 1 never executed 469: #####: 368: *error_code = MPIO_Err_create_code(MPI_SUCCESS, 475: -: 371: "**io %s", strerror(errno)); 476: -: 372: } 477: #####: 373: else *error_code = MPI_SUCCESS; 481: -: 377: 482: -: 378:/* filetype already flattened in ADIO_Open */ 483: #####: 379: flat_file = ADIOI_Flatlist; 484: #####: 380: while (flat_file->type != fd->filetype) flat_file = flat_file->next; 485: branch 0 never executed 486: branch 1 never executed 487: #####: 381: disp = fd->disp; 488: -: 382: 489: #####: 383: if (file_ptr_type == ADIO_INDIVIDUAL) { 491: branch 1 never executed 492: -: 384: /* Wei-keng reworked type processing to be a bit more efficient */ 493: #####: 385: offset = fd->fp_ind - disp; 494: #####: 386: n_filetypes = (offset - flat_file->indices[0]) / filetype_extent; 495: #####: 387: offset -= (ADIO_Offset)n_filetypes * filetype_extent; 497: -: 389: 498: -: 390: /* find the block where offset is located, skip blocklens[i]==0 */ 499: #####: 391: for (i=0; icount; i++) { 501: branch 1 never executed 502: -: 392: ADIO_Offset dist; 503: #####: 393: if (flat_file->blocklens[i] == 0) continue; 504: branch 0 never executed 505: branch 1 never executed 506: #####: 394: dist = flat_file->indices[i] + flat_file->blocklens[i] - offset; 507: -: 395: /* fwr_size is from offset to the end of block i */ 508: #####: 396: if (dist == 0) { 509: branch 0 never executed 510: branch 1 never executed 511: #####: 397: i++; 512: #####: 398: offset = flat_file->indices[i]; 513: #####: 399: fwr_size = flat_file->blocklens[i]; 514: #####: 400: break; 515: -: 401: } 516: #####: 402: if (dist > 0) { 517: branch 0 never executed 518: branch 1 never executed 519: #####: 403: fwr_size = dist; 520: #####: 404: break; 521: -: 405: } 522: -: 406: } 523: #####: 407: st_index = i; /* starting index in flat_file->indices[] */ 524: #####: 408: offset += disp + (ADIO_Offset)n_filetypes*filetype_extent; 525: -: 409: } 526: -: 410: else { 527: #####: 411: n_etypes_in_filetype = filetype_size/etype_size; 528: #####: 412: n_filetypes = (int) (offset / n_etypes_in_filetype); 529: #####: 413: etype_in_filetype = (int) (offset % n_etypes_in_filetype); 530: #####: 414: size_in_filetype = etype_in_filetype * etype_size; 531: -: 415: 532: #####: 416: sum = 0; 533: #####: 417: for (i=0; icount; i++) { 534: branch 0 never executed 535: branch 1 never executed 536: #####: 418: sum += flat_file->blocklens[i]; 537: #####: 419: if (sum > size_in_filetype) { 538: branch 0 never executed 539: branch 1 never executed 540: #####: 420: st_index = i; 541: #####: 421: fwr_size = sum - size_in_filetype; 542: #####: 422: abs_off_in_filetype = flat_file->indices[i] + 543: -: 423: size_in_filetype - (sum - flat_file->blocklens[i]); 544: #####: 424: break; 547: -: 427: 548: -: 428: /* abs. offset in bytes in the file */ 549: #####: 429: offset = disp + (ADIO_Offset) n_filetypes*filetype_extent + 551: -: 431: } 552: -: 432: 553: #####: 433: start_off = offset; 555: -: 435: /* this could happen, for example, with subarray types that are 556: -: 436: * actually fairly contiguous */ 557: #####: 437: if (buftype_is_contig && bufsize <= fwr_size) { 558: branch 0 never executed 559: branch 1 never executed 560: #####: 438: ADIO_WriteContig(fd, buf, bufsize, MPI_BYTE, ADIO_EXPLICIT_OFFSET, 562: -: 439: offset, status, error_code); 563: -: 440: 564: #####: 441: if (file_ptr_type == ADIO_INDIVIDUAL) { 567: -: 442: /* update MPI-IO file pointer to point to the first byte 568: -: 443: * that can be accessed in the fileview. */ 569: #####: 444: fd->fp_ind = offset + bufsize; 570: #####: 445: if (bufsize == fwr_size) { 572: branch 1 never executed 573: -: 446: do { 574: #####: 447: st_index++; 575: #####: 448: if (st_index == flat_file->count) { 576: branch 0 never executed 577: branch 1 never executed 578: #####: 449: st_index = 0; 579: #####: 450: n_filetypes++; 580: -: 451: } 581: #####: 452: } while (flat_file->blocklens[st_index] == 0); 582: branch 0 never executed 583: branch 1 never executed 584: #####: 453: fd->fp_ind = disp + flat_file->indices[st_index] 586: -: 455: } 587: -: 456: } 588: #####: 457: fd->fp_sys_posn = -1; /* set it to null. */ 589: -: 458:#ifdef HAVE_STATUS_SET_BYTES 590: #####: 459: MPIR_Status_set_bytes(status, datatype, bufsize); 591: call 0 never executed 592: -: 460:#endif 593: #####: 461: return; 597: -: 465: e.g., if start_offset=0 and 100 bytes to be write, end_offset=99*/ 598: -: 466: 599: #####: 467: st_fwr_size = fwr_size; 600: #####: 468: st_n_filetypes = n_filetypes; 601: #####: 469: i = 0; 602: #####: 470: j = st_index; 603: #####: 471: off = offset; 604: #####: 472: fwr_size = ADIOI_MIN(st_fwr_size, bufsize); 605: #####: 473: while (i < bufsize) { 606: branch 0 never executed 607: branch 1 never executed 608: #####: 474: i += fwr_size; 609: #####: 475: end_offset = off + fwr_size - 1; 610: #####: 476: j = (j+1) % flat_file->count; 611: #####: 477: n_filetypes += (j == 0) ? 1 : 0; 612: #####: 478: while (flat_file->blocklens[j]==0) { 613: branch 0 never executed 614: branch 1 never executed 615: #####: 479: j = (j+1) % flat_file->count; 616: #####: 480: n_filetypes += (j == 0) ? 1 : 0; 617: -: 481: } 618: -: 482: 619: #####: 483: off = disp + flat_file->indices[j] + 620: -: 484: (ADIO_Offset) n_filetypes*filetype_extent; 621: #####: 485: fwr_size = ADIOI_MIN(flat_file->blocklens[j], bufsize-i); 623: -: 487: 624: -: 488:/* if atomicity is true, lock the region to be accessed */ 625: #####: 489: if (fd->atomicity) 626: branch 0 never executed 627: branch 1 never executed 628: #####: 490: ADIOI_WRITE_LOCK(fd, start_off, SEEK_SET, end_offset-start_off+1); 630: -: 491: 631: -: 492: /* initial read for the read-modify-write */ 632: #####: 493: writebuf_off = offset; 633: #####: 494: writebuf = (char *) ADIOI_Malloc(max_bufsize); 634: call 0 never executed 635: #####: 495: writebuf_len = (int)(ADIOI_MIN(max_bufsize,end_offset-writebuf_off+1)); 636: #####: 496: if (!(fd->atomicity)) ADIOI_WRITE_LOCK(fd, writebuf_off, SEEK_SET, writebuf_len); 641: -: 498: MPE_Log_event( ADIOI_MPE_lseek_a, 0, NULL ); 642: -: 499:#endif 643: #####: 500: lseek(fd->fd_sys, writebuf_off, SEEK_SET); 649: -: 505: MPE_Log_event( ADIOI_MPE_read_a, 0, NULL ); 650: -: 506:#endif 651: #####: 507: err = read(fd->fd_sys, writebuf, writebuf_len); 654: -: 509: MPE_Log_event( ADIOI_MPE_read_b, 0, NULL ); 655: -: 510:#endif 656: #####: 511: if (err == -1) { 657: branch 0 never executed 658: branch 1 never executed 659: #####: 512: *error_code = MPIO_Err_create_code(MPI_SUCCESS, 663: -: 515: MPI_ERR_IO, 664: -: 516: "ADIOI_NFS_WriteStrided: ROMIO tries to optimize this access by doing a read-modify-write, but is unable to read the file. Please give the file read permission and open it with MPI_MODE_RDWR.", 0); 665: #####: 517: return; 666: -: 518: } 667: -: 519: 668: #####: 520: if (buftype_is_contig && !filetype_is_contig) { 675: -: 523: common case. */ 676: -: 524: 677: #####: 525: i = 0; 678: #####: 526: j = st_index; 679: #####: 527: off = offset; 680: #####: 528: n_filetypes = st_n_filetypes; 681: #####: 529: fwr_size = ADIOI_MIN(st_fwr_size, bufsize); 682: #####: 530: while (i < bufsize) { 683: branch 0 never executed 684: branch 1 never executed 685: #####: 531: if (fwr_size) { 691: -: 535: err = write(fd->fd_sys, ((char *) buf) + i, fwr_size);*/ 692: -: 536: 693: #####: 537: req_off = off; 694: #####: 538: req_len = fwr_size; 695: #####: 539: userbuf_off = i; 696: #####: 540: ADIOI_BUFFERED_WRITE 732: branch 35 never executed 733: -: 541: } 734: #####: 542: i += fwr_size; 735: -: 543: 736: #####: 544: if (off + fwr_size < disp + flat_file->indices[j] + 738: branch 1 never executed 739: -: 545: flat_file->blocklens[j] + (ADIO_Offset) n_filetypes*filetype_extent) 740: #####: 546: off += fwr_size; 742: -: 548: no more I/O needed. off is incremented by fwr_size. */ 743: -: 549: else { 744: #####: 550: j = (j+1) % flat_file->count; 745: #####: 551: n_filetypes += (j == 0) ? 1 : 0; 746: #####: 552: while (flat_file->blocklens[j]==0) { 747: branch 0 never executed 748: branch 1 never executed 749: #####: 553: j = (j+1) % flat_file->count; 750: #####: 554: n_filetypes += (j == 0) ? 1 : 0; 751: -: 555: } 752: #####: 556: off = disp + flat_file->indices[j] + 753: -: 557: (ADIO_Offset) n_filetypes*filetype_extent; 754: #####: 558: fwr_size = ADIOI_MIN(flat_file->blocklens[j], bufsize-i); 759: -: 563:/* noncontiguous in memory as well as in file */ 760: -: 564: 761: #####: 565: ADIOI_Flatten_datatype(datatype); 762: call 0 never executed 763: #####: 566: flat_buf = ADIOI_Flatlist; 764: #####: 567: while (flat_buf->type != datatype) flat_buf = flat_buf->next; 766: branch 1 never executed 767: -: 568: 768: #####: 569: k = num = buf_count = 0; 769: #####: 570: i = (int) (flat_buf->indices[0]); 770: #####: 571: j = st_index; 771: #####: 572: off = offset; 772: #####: 573: n_filetypes = st_n_filetypes; 773: #####: 574: fwr_size = st_fwr_size; 774: #####: 575: bwr_size = flat_buf->blocklens[0]; 775: -: 576: 776: #####: 577: while (num < bufsize) { 777: branch 0 never executed 778: branch 1 never executed 779: #####: 578: size = ADIOI_MIN(fwr_size, bwr_size); 780: #####: 579: if (size) { 784: -: 581: err = write(fd->fd_sys, ((char *) buf) + i, size); */ 785: -: 582: 786: #####: 583: req_off = off; 787: #####: 584: req_len = size; 788: #####: 585: userbuf_off = i; 789: #####: 586: ADIOI_BUFFERED_WRITE 826: -: 587: } 827: -: 588: 828: #####: 589: new_fwr_size = fwr_size; 829: #####: 590: new_bwr_size = bwr_size; 830: -: 591: 831: #####: 592: if (size == fwr_size) { 833: branch 1 never executed 834: -: 593:/* reached end of contiguous block in file */ 835: #####: 594: j = (j+1) % flat_file->count; 836: #####: 595: n_filetypes += (j == 0) ? 1 : 0; 837: #####: 596: while (flat_file->blocklens[j]==0) { 838: branch 0 never executed 839: branch 1 never executed 840: #####: 597: j = (j+1) % flat_file->count; 841: #####: 598: n_filetypes += (j == 0) ? 1 : 0; 842: -: 599: } 843: -: 600: 844: #####: 601: off = disp + flat_file->indices[j] + 845: -: 602: (ADIO_Offset) n_filetypes*filetype_extent; 846: -: 603: 847: #####: 604: new_fwr_size = flat_file->blocklens[j]; 848: #####: 605: if (size != bwr_size) { 849: branch 0 never executed 850: branch 1 never executed 851: #####: 606: i += size; 852: #####: 607: new_bwr_size -= size; 854: -: 609: } 855: -: 610: 856: #####: 611: if (size == bwr_size) { 859: -: 612:/* reached end of contiguous block in memory */ 860: -: 613: 861: #####: 614: k = (k + 1)%flat_buf->count; 862: #####: 615: buf_count++; 863: #####: 616: i = (int) (buftype_extent*(buf_count/flat_buf->count) + 864: -: 617: flat_buf->indices[k]); 865: #####: 618: new_bwr_size = flat_buf->blocklens[k]; 866: #####: 619: if (size != fwr_size) { 867: branch 0 never executed 868: branch 1 never executed 869: #####: 620: off += size; 870: #####: 621: new_fwr_size -= size; 871: -: 622: } 872: -: 623: } 873: #####: 624: num += size; 874: #####: 625: fwr_size = new_fwr_size; 875: #####: 626: bwr_size = new_bwr_size; 881: -: 632: MPE_Log_event( ADIOI_MPE_lseek_a, 0, NULL ); 882: -: 633:#endif 883: #####: 634: lseek(fd->fd_sys, writebuf_off, SEEK_SET); 886: -: 636: MPE_Log_event( ADIOI_MPE_lseek_b, 0, NULL ); 887: -: 637:#endif 888: #####: 638: if (!(fd->atomicity)) ADIOI_WRITE_LOCK(fd, writebuf_off, SEEK_SET, writebuf_len); 893: -: 640: MPE_Log_event( ADIOI_MPE_write_a, 0, NULL ); 894: -: 641:#endif 895: #####: 642: err = write(fd->fd_sys, writebuf, writebuf_len); 899: -: 645:#endif 900: -: 646: 901: #####: 647: if (!(fd->atomicity)) 902: branch 0 never executed 903: branch 1 never executed 904: #####: 648: ADIOI_UNLOCK(fd, writebuf_off, SEEK_SET, writebuf_len); 905: call 0 never executed 906: #####: 649: else ADIOI_UNLOCK(fd, start_off, SEEK_SET, end_offset-start_off+1); 907: call 0 never executed 908: -: 650: 909: #####: 651: if (err == -1) err_flag = 1; 911: branch 1 never executed 912: -: 652: 913: #####: 653: ADIOI_Free(writebuf); /* malloced in the buffered_write macro */ 914: call 0 never executed 915: -: 654: 916: #####: 655: if (file_ptr_type == ADIO_INDIVIDUAL) fd->fp_ind = off; 917: branch 0 never executed 918: branch 1 never executed 919: #####: 656: if (err_flag) { 920: branch 0 never executed 921: branch 1 never executed 922: #####: 657: *error_code = MPIO_Err_create_code(MPI_SUCCESS, 928: -: 660: "**io %s", strerror(errno)); 929: -: 661: } 930: #####: 662: else *error_code = MPI_SUCCESS; 931: -: 663: } 932: -: 664: 933: #####: 665: fd->fp_sys_posn = -1; /* set it to null. */ 934: -: 666: 935: -: 667:#ifdef HAVE_STATUS_SET_BYTES 936: #####: 668: MPIR_Status_set_bytes(status, datatype, bufsize); 940: -: 671:#endif 941: -: 672: 942: #####: 673: if (!buftype_is_contig) ADIOI_Delete_flattened(datatype); 225 line(s) not covered by tests in src/mpi/romio/adio/ad_nfs/ad_nfs_write.c.gcov Uncovered lines in src/mpi/romio/adio/ad_nfs/ad_nfs_done.c.gcov 15: -: 10: int *error_code) 16: function ADIOI_NFS_ReadDone called 0 returned 0% blocks executed 0% 17: #####: 11:{ 18: #####: 12: *error_code = MPI_SUCCESS; 19: #####: 13: return 1; 22: -: 16: int *error_code) 23: function ADIOI_NFS_WriteDone called 0 returned 0% blocks executed 0% 24: #####: 17:{ 25: #####: 18: return ADIOI_NFS_ReadDone(request, status, error_code); 5 line(s) not covered by tests in src/mpi/romio/adio/ad_nfs/ad_nfs_done.c.gcov Uncovered lines in src/mpi/romio/adio/ad_nfs/ad_nfs_fcntl.c.gcov 19: -: 14:void ADIOI_NFS_Fcntl(ADIO_File fd, int flag, ADIO_Fcntl_t *fcntl_struct, int *error_code) 20: function ADIOI_NFS_Fcntl called 0 returned 0% blocks executed 0% 21: #####: 15:{ 22: -: 16: static char myname[] = "ADIOI_NFS_FCNTL"; 23: -: 17: 24: #####: 18: switch(flag) { 28: branch 3 never executed 29: -: 19: case ADIO_FCNTL_GET_FSIZE: 30: #####: 20: ADIOI_READ_LOCK(fd, 0, SEEK_SET, 1); 33: -: 22: MPE_Log_event( ADIOI_MPE_lseek_a, 0, NULL ); 34: -: 23:#endif 35: #####: 24: fcntl_struct->fsize = lseek(fd->fd_sys, 0, SEEK_END); 38: -: 26: MPE_Log_event( ADIOI_MPE_lseek_b, 0, NULL ); 39: -: 27:#endif 40: #####: 28: ADIOI_UNLOCK(fd, 0, SEEK_SET, 1); 41: call 0 never executed 42: #####: 29: if (fd->fp_sys_posn != -1) { 46: -: 31: MPE_Log_event( ADIOI_MPE_lseek_a, 0, NULL ); 47: -: 32:#endif 48: #####: 33: lseek(fd->fd_sys, fd->fp_sys_posn, SEEK_SET); 52: -: 36:#endif 53: -: 37: } 54: #####: 38: if (fcntl_struct->fsize == -1) { 55: branch 0 never executed 56: branch 1 never executed 57: #####: 39: *error_code = MPIO_Err_create_code(MPI_SUCCESS, 63: -: 42: "**io %s", strerror(errno)); 64: -: 43: } 65: #####: 44: else *error_code = MPI_SUCCESS; 67: -: 46: 68: -: 47: case ADIO_FCNTL_SET_DISKSPACE: 69: #####: 48: ADIOI_GEN_Prealloc(fd, fcntl_struct->diskspace, error_code); 70: call 0 never executed 71: #####: 49: break; 72: -: 50: 73: -: 51: case ADIO_FCNTL_SET_ATOMICITY: 74: #####: 52: fd->atomicity = (fcntl_struct->atomicity == 0) ? 0 : 1; 75: #####: 53: *error_code = MPI_SUCCESS; 76: #####: 54: break; 15 line(s) not covered by tests in src/mpi/romio/adio/ad_nfs/ad_nfs_fcntl.c.gcov Uncovered lines in src/mpi/romio/adio/ad_nfs/ad_nfs_iread.c.gcov 19: -: 14: int *error_code) 20: function ADIOI_NFS_IreadContig called 0 returned 0% blocks executed 0% 21: #####: 15:{ 22: -: 16: int len, typesize; 23: #####: 17: int aio_errno = 0; 24: -: 18: static char myname[] = "ADIOI_NFS_IREADCONTIG"; 25: -: 19: 26: #####: 20: MPI_Type_size(datatype, &typesize); 27: call 0 never executed 28: #####: 21: len = count * typesize; 29: -: 22: 30: #####: 23: if (file_ptr_type == ADIO_INDIVIDUAL) offset = fd->fp_ind; 31: branch 0 never executed 32: branch 1 never executed 33: #####: 24: aio_errno = ADIOI_NFS_aio(fd, buf, len, offset, 0, request); 34: call 0 never executed 35: #####: 25: if (file_ptr_type == ADIO_INDIVIDUAL) fd->fp_ind += len; 37: branch 1 never executed 38: -: 26: 39: #####: 27: fd->fp_sys_posn = -1; 40: -: 28: 41: #####: 29: if (aio_errno != 0) { 49: branch 1 never executed 50: -: 34: } 51: #####: 35: else *error_code = MPI_SUCCESS; 10 line(s) not covered by tests in src/mpi/romio/adio/ad_nfs/ad_nfs_iread.c.gcov Uncovered lines in src/mpi/romio/adio/ad_nfs/ad_nfs_iwrite.c.gcov 26: -: 21: ADIO_Offset offset, ADIO_Request *request, int *error_code) 27: function ADIOI_NFS_IwriteContig called 0 returned 0% blocks executed 0% 28: #####: 22:{ 29: -: 23: int len, typesize; 30: #####: 24: int aio_errno = 0; 31: -: 25: static char myname[] = "ADIOI_NFS_IWRITECONTIG"; 32: -: 26: 33: #####: 27: MPI_Type_size(datatype, &typesize); 34: call 0 never executed 35: #####: 28: len = count * typesize; 36: -: 29: 37: #####: 30: if (file_ptr_type == ADIO_INDIVIDUAL) offset = fd->fp_ind; 38: branch 0 never executed 39: branch 1 never executed 40: #####: 31: aio_errno = ADIOI_NFS_aio(fd, buf, len, offset, 1, request); 41: call 0 never executed 42: #####: 32: if (file_ptr_type == ADIO_INDIVIDUAL) fd->fp_ind += len; 44: branch 1 never executed 45: -: 33: 46: #####: 34: fd->fp_sys_posn = -1; 47: -: 35: 48: #####: 36: if (aio_errno != 0) { 56: branch 1 never executed 57: -: 41: } 58: #####: 42: else *error_code = MPI_SUCCESS; 59: #####: 43: return; 71: -: 55: int wr, MPI_Request *request) 72: function ADIOI_NFS_aio called 0 returned 0% blocks executed 0% 73: #####: 56:{ 74: #####: 57: int err=-1, fd_sys; 78: -: 61: ADIOI_AIO_Request *aio_req; 79: -: 62: 80: #####: 63: fd_sys = fd->fd_sys; 81: -: 64: 82: #####: 65: aio_req = (ADIOI_AIO_Request*)ADIOI_Calloc(sizeof(ADIOI_AIO_Request), 1); 83: call 0 never executed 84: #####: 66: aiocbp = (struct aiocb *) ADIOI_Calloc(sizeof(struct aiocb), 1); 85: call 0 never executed 86: #####: 67: aiocbp->aio_offset = offset; 87: #####: 68: aiocbp->aio_buf = buf; 88: #####: 69: aiocbp->aio_nbytes = len; 92: -: 73:#endif 93: -: 74:#ifdef ROMIO_HAVE_STRUCT_AIOCB_WITH_AIO_FILDES 94: #####: 75: aiocbp->aio_fildes = fd_sys; 98: -: 79: aiocbp->aio_sigevent.sigev_notify = SIGEV_NONE; 99: -: 80:# endif 100: #####: 81: aiocbp->aio_sigevent.sigev_signo = 0; 104: -: 85: aiocbp->aio_reqprio = AIO_PRIO_DFL; /* not needed in DEC Unix 4.0 */ 105: -: 86:# else 106: #####: 87: aiocbp->aio_reqprio = 0; 108: -: 89:#endif 109: -: 90: 110: #####: 91: if (wr) ADIOI_WRITE_LOCK(fd, offset, SEEK_SET, len); 112: branch 1 never executed 113: call 2 never executed 114: #####: 92: else ADIOI_READ_LOCK(fd, offset, SEEK_SET, len); 116: -: 93: 117: -: 94:#ifndef ROMIO_HAVE_AIO_CALLS_NEED_FILEDES 118: #####: 95: if (wr) err = aio_write(aiocbp); 120: branch 1 never executed 121: call 2 never executed 122: #####: 96: else err = aio_read(aiocbp); 128: -: 101:#endif 129: -: 102: 130: #####: 103: this_errno = errno; 131: call 0 never executed 132: #####: 104: ADIOI_UNLOCK(fd, offset, SEEK_SET, len); 133: call 0 never executed 134: -: 105: 135: #####: 106: if (err == -1) { 136: branch 0 never executed 137: branch 1 never executed 138: #####: 107: if (this_errno == EAGAIN) { 141: -: 108: /* exceeded the max. no. of outstanding requests. 142: -: 109: complete all previous async. requests and try again. */ 143: #####: 110: ADIO_WriteContig(fd, buf, len, MPI_BYTE, ADIO_EXPLICIT_OFFSET, 144: call 0 never executed 145: -: 111: offset, NULL, &error_code); 146: #####: 112: MPIO_Completed_request_create(&fd, len, &error_code, request); 147: call 0 never executed 148: #####: 113: return 0; 149: -: 114: } else { 150: #####: 115: return -this_errno; 151: -: 116: } 152: -: 117: } 153: #####: 118: aio_req->aiocbp = aiocbp; 154: #####: 119: if (ADIOI_GEN_greq_class == 0) { 155: branch 0 never executed 156: branch 1 never executed 157: #####: 120: MPIX_Grequest_class_create(ADIOI_GEN_aio_query_fn, 161: -: 123: &ADIOI_GEN_greq_class); 162: -: 124: } 163: #####: 125: MPIX_Grequest_class_allocate(ADIOI_GEN_greq_class, aio_req, request); 164: call 0 never executed 165: #####: 126: memcpy(&(aio_req->req), request, sizeof(MPI_Request)); 166: call 0 never executed 167: #####: 127: return 0; 40 line(s) not covered by tests in src/mpi/romio/adio/ad_nfs/ad_nfs_iwrite.c.gcov Uncovered lines in src/mpi/romio/adio/ad_nfs/ad_nfs_wait.c.gcov 15: -: 10: int *error_code) 16: function ADIOI_NFS_ReadComplete called 0 returned 0% blocks executed 0% 17: #####: 11:{ 133: -: 127: int *error_code) 134: function ADIOI_NFS_WriteComplete called 0 returned 0% blocks executed 0% 135: #####: 128:{ 136: #####: 129: ADIOI_NFS_ReadComplete(request, status, error_code); 3 line(s) not covered by tests in src/mpi/romio/adio/ad_nfs/ad_nfs_wait.c.gcov Uncovered lines in src/mpi/romio/adio/ad_nfs/ad_nfs_setsh.c.gcov 36: -: 31:void ADIOI_NFS_Set_shared_fp(ADIO_File fd, ADIO_Offset offset, int *error_code) 37: function ADIOI_NFS_Set_shared_fp called 0 returned 0% blocks executed 0% 38: #####: 32:{ 41: -: 35: static char myname[] = "ADIOI_NFS_SET_SHARED_FP"; 42: -: 36: 43: #####: 37: if (fd->shared_fp_fd == ADIO_FILE_NULL) { 44: branch 0 never executed 45: branch 1 never executed 46: #####: 38: MPI_Comm_dup(MPI_COMM_SELF, &dupcommself); 47: call 0 never executed 48: #####: 39: fd->shared_fp_fd = ADIO_Open(MPI_COMM_SELF, dupcommself, 55: -: 45: } 56: -: 46: 57: #####: 47: if (*error_code != MPI_SUCCESS) return; 59: branch 1 never executed 60: -: 48: 61: #####: 49: ADIOI_WRITE_LOCK(fd->shared_fp_fd, 0, SEEK_SET, sizeof(ADIO_Offset)); 64: -: 51: MPE_Log_event( ADIOI_MPE_lseek_a, 0, NULL ); 65: -: 52:#endif 66: #####: 53: lseek(fd->shared_fp_fd->fd_sys, 0, SEEK_SET); 72: -: 58: MPE_Log_event( ADIOI_MPE_write_a, 0, NULL ); 73: -: 59:#endif 74: #####: 60: err = write(fd->shared_fp_fd->fd_sys, &offset, sizeof(ADIO_Offset)); 77: -: 62: MPE_Log_event( ADIOI_MPE_write_b, 0, NULL ); 78: -: 63:#endif 79: #####: 64: ADIOI_UNLOCK(fd->shared_fp_fd, 0, SEEK_SET, sizeof(ADIO_Offset)); 80: call 0 never executed 81: -: 65: 82: #####: 66: if (err == -1) { 83: branch 0 never executed 84: branch 1 never executed 85: #####: 67: *error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, 91: -: 70: "**io %s", strerror(errno)); 92: -: 71: } 93: #####: 72: else *error_code = MPI_SUCCESS; 12 line(s) not covered by tests in src/mpi/romio/adio/ad_nfs/ad_nfs_setsh.c.gcov Uncovered lines in src/mpi/romio/adio/ad_nfs/ad_nfs_getsh.c.gcov 21: -: 16: int *error_code) 22: function ADIOI_NFS_Get_shared_fp called 0 returned 0% blocks executed 0% 23: #####: 17:{ 27: -: 21: static char myname[] = "ADIOI_NFS_GET_SHARED_FP"; 28: -: 22: 29: #####: 23: if (fd->shared_fp_fd == ADIO_FILE_NULL) { 30: branch 0 never executed 31: branch 1 never executed 32: #####: 24: MPI_Comm_dup(MPI_COMM_SELF, &dupcommself); 33: call 0 never executed 34: #####: 25: fd->shared_fp_fd = ADIO_Open(MPI_COMM_SELF, dupcommself, 40: -: 30: 0, MPI_BYTE, MPI_BYTE, MPI_INFO_NULL, 41: -: 31: ADIO_PERM_NULL, error_code); 42: #####: 32: if (*error_code != MPI_SUCCESS) return; 43: branch 0 never executed 44: branch 1 never executed 45: #####: 33: *shared_fp = 0; 46: #####: 34: ADIOI_WRITE_LOCK(fd->shared_fp_fd, 0, SEEK_SET, sizeof(ADIO_Offset)); 49: -: 36: MPE_Log_event( ADIOI_MPE_read_a, 0, NULL ); 50: -: 37:#endif 51: #####: 38: err = read(fd->shared_fp_fd->fd_sys, shared_fp, sizeof(ADIO_Offset)); 59: -: 45: } 60: -: 46: else { 61: #####: 47: ADIOI_WRITE_LOCK(fd->shared_fp_fd, 0, SEEK_SET, sizeof(ADIO_Offset)); 65: -: 50: MPE_Log_event( ADIOI_MPE_lseek_a, 0, NULL ); 66: -: 51:#endif 67: #####: 52: err = lseek(fd->shared_fp_fd->fd_sys, 0, SEEK_SET); 70: -: 54: MPE_Log_event( ADIOI_MPE_lseek_b, 0, NULL ); 71: -: 55:#endif 72: #####: 56: if (err == 0) { 76: -: 58: MPE_Log_event( ADIOI_MPE_read_a, 0, NULL ); 77: -: 59:#endif 78: #####: 60: err = read(fd->shared_fp_fd->fd_sys, shared_fp, 83: -: 64:#endif 84: -: 65: } 85: #####: 66: if (err == -1) { 86: branch 0 never executed 87: branch 1 never executed 88: #####: 67: ADIOI_UNLOCK(fd->shared_fp_fd, 0, SEEK_SET, sizeof(ADIO_Offset)); 89: call 0 never executed 90: #####: 68: *error_code = MPIO_Err_create_code(MPI_SUCCESS, 95: -: 70: __LINE__, MPI_ERR_IO, "**io", 96: -: 71: "**io %s", strerror(errno)); 97: #####: 72: return; 99: -: 74: } 100: -: 75: 101: #####: 76: new_fp = *shared_fp + incr; 104: -: 79: MPE_Log_event( ADIOI_MPE_lseek_a, 0, NULL ); 105: -: 80:#endif 106: #####: 81: err = lseek(fd->shared_fp_fd->fd_sys, 0, SEEK_SET); 109: -: 83: MPE_Log_event( ADIOI_MPE_lseek_b, 0, NULL ); 110: -: 84:#endif 111: #####: 85: if (err == 0) { 115: -: 87: MPE_Log_event( ADIOI_MPE_write_a, 0, NULL ); 116: -: 88:#endif 117: #####: 89: err = write(fd->shared_fp_fd->fd_sys, &new_fp, sizeof(ADIO_Offset)); 121: -: 92:#endif 122: -: 93: } 123: #####: 94: ADIOI_UNLOCK(fd->shared_fp_fd, 0, SEEK_SET, sizeof(ADIO_Offset)); 124: call 0 never executed 125: #####: 95: if (err == -1) { 126: branch 0 never executed 127: branch 1 never executed 128: #####: 96: *error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, 134: -: 99: "**io %s", strerror(errno)); 135: -: 100: } 136: #####: 101: else *error_code = MPI_SUCCESS; 24 line(s) not covered by tests in src/mpi/romio/adio/ad_nfs/ad_nfs_getsh.c.gcov Uncovered lines in src/mpi/romio/adio/ad_nfs/ad_nfs_resize.c.gcov 25: -: 20:void ADIOI_NFS_Resize(ADIO_File fd, ADIO_Offset size, int *error_code) 26: function ADIOI_NFS_Resize called 0 returned 0% blocks executed 0% 27: #####: 21:{ 29: -: 23: static char myname[] = "ADIOI_GEN_RESIZE"; 30: -: 24: 31: #####: 25: err = ftruncate(fd->fd_sys, size); 46: -: 26: 47: -: 35: 48: #####: 36: *error_code = MPI_SUCCESS; 3 line(s) not covered by tests in src/mpi/romio/adio/ad_nfs/ad_nfs_resize.c.gcov Uncovered lines in src/mpi/romio/adio/ad_nfs/ad_nfs_features.c.gcov 9: -: 4:int ADIOI_NFS_Feature(ADIO_File fd, int flag) 10: function ADIOI_NFS_Feature called 0 returned 0% blocks executed 0% 11: #####: 5:{ 12: #####: 6: switch(flag) { 17: -: 9: case ADIO_SEQUENTIAL: 18: -: 10: case ADIO_DATA_SIEVING_WRITES: 19: #####: 11: return 1; 20: -: 12: case ADIO_SCALABLE_OPEN: 21: -: 13: default: 22: #####: 14: return 0; 4 line(s) not covered by tests in src/mpi/romio/adio/ad_nfs/ad_nfs_features.c.gcov Uncovered lines in src/mpi/romio/adio/ad_ufs/ad_ufs_open.c.gcov 28: 5572: 18: perm = old_mask ^ 0666; 29: -: 19: } 30: #####: 20: else perm = fd->perm; 71: -: 46: MPE_Log_event( ADIOI_MPE_lseek_a, 0, NULL ); 72: -: 47:#endif 73: #####: 48: fd->fp_ind = fd->fp_sys_posn = lseek(fd->fd_sys, 0, SEEK_END); 2 line(s) not covered by tests in src/mpi/romio/adio/ad_ufs/ad_ufs_open.c.gcov All code covered by tests in src/mpi/romio/mpi-io/close.c.gcov All code covered by tests in src/mpi/romio/mpi-io/read.c.gcov Uncovered lines in src/mpi/romio/mpi-io/open.c.gcov 179: branch 0 taken 0% (fallthrough) 180: branch 1 taken 100% 181: #####: 146: filename = tmp + 1; 208: branch 4 never executed 209: -: 165: { 210: #####: 166: error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, 213: -: 168: MPI_ERR_UNSUPPORTED_OPERATION, 214: -: 169: "**iosequnsupported", 0); 215: #####: 170: ADIO_Close(*fh, &error_code); 239: branch 0 taken 0% (fallthrough) 240: branch 1 taken 100% 241: #####: 186: if (rank == (*fh)->hints->ranklist[0]) /* only one person need set the sharedfp */ 242: branch 0 never executed 243: branch 1 never executed 244: #####: 187: ADIO_Set_shared_fp(*fh, (*fh)->fp_ind, &error_code); 245: call 0 never executed 246: #####: 188: MPI_Barrier(dupcomm); 6 line(s) not covered by tests in src/mpi/romio/mpi-io/open.c.gcov All code covered by tests in src/mpi/romio/mpi-io/write.c.gcov All code covered by tests in src/mpi/romio/mpi-io/set_view.c.gcov Uncovered lines in src/mpi/romio/mpi-io/iread.c.gcov 200: -: 138: /* to maintain strict atomicity semantics with other concurrent 201: -: 139: operations, lock (exclusive) and call blocking routine */ 202: #####: 140: if (ADIO_Feature(fh, ADIO_LOCKS)) 205: branch 2 never executed 206: -: 141: { 207: #####: 142: ADIOI_WRITE_LOCK(fh, off, SEEK_SET, bufsize); 209: -: 143: } 210: -: 144: 211: #####: 145: ADIO_ReadContig(fh, buf, count, datatype, file_ptr_type, 213: -: 146: off, &status, &error_code); 214: -: 147: 215: #####: 148: if (ADIO_Feature(fh, ADIO_LOCKS)) 218: branch 2 never executed 219: -: 149: { 220: #####: 150: ADIOI_UNLOCK(fh, off, SEEK_SET, bufsize); 221: call 0 never executed 222: -: 151: } 223: #####: 152: if (error_code == MPI_SUCCESS) { 224: branch 0 never executed 225: branch 1 never executed 226: #####: 153: nbytes = count*datatype_size; 227: -: 154: } 228: #####: 155: MPIO_Completed_request_create(&fh, nbytes, &error_code, request); 8 line(s) not covered by tests in src/mpi/romio/mpi-io/iread.c.gcov Uncovered lines in src/mpi/romio/mpi-io/iwrite.c.gcov 202: -: 140: /* to maintain strict atomicity semantics with other concurrent 203: -: 141: operations, lock (exclusive) and call blocking routine */ 204: #####: 142: if (ADIO_Feature(fh, ADIO_LOCKS) ) 207: branch 2 never executed 208: -: 143: { 209: #####: 144: ADIOI_WRITE_LOCK(fh, off, SEEK_SET, bufsize); 211: -: 145: } 212: -: 146: 213: #####: 147: ADIO_WriteContig(fh, buf, count, datatype, file_ptr_type, off, 215: -: 148: &status, &error_code); 216: -: 149: 217: #####: 150: if (ADIO_Feature(fh, ADIO_LOCKS) ) 220: branch 2 never executed 221: -: 151: { 222: #####: 152: ADIOI_UNLOCK(fh, off, SEEK_SET, bufsize); 223: call 0 never executed 224: -: 153: } 225: #####: 154: if (error_code == MPI_SUCCESS) { 226: branch 0 never executed 227: branch 1 never executed 228: #####: 155: nbytes = count * datatype_size; 229: -: 156: } 230: -: 157: 231: #####: 158: MPIO_Completed_request_create(&fh, nbytes, &error_code, request); 8 line(s) not covered by tests in src/mpi/romio/mpi-io/iwrite.c.gcov All code covered by tests in src/mpi/romio/mpi-io/seek.c.gcov All code covered by tests in src/mpi/romio/mpi-io/get_posn.c.gcov Uncovered lines in src/mpi/romio/mpi-io/delete.c.gcov 95: branch 0 taken 0% (fallthrough) 96: branch 1 taken 100% 97: #####: 80: filename = tmp + 1; 1 line(s) not covered by tests in src/mpi/romio/mpi-io/delete.c.gcov All code covered by tests in src/mpi/romio/mpi-io/read_all.c.gcov All code covered by tests in src/mpi/romio/mpi-io/read_at.c.gcov All code covered by tests in src/mpi/romio/mpi-io/read_atall.c.gcov All code covered by tests in src/mpi/romio/mpi-io/iread_at.c.gcov All code covered by tests in src/mpi/romio/mpi-io/iwrite_at.c.gcov All code covered by tests in src/mpi/romio/mpi-io/write_all.c.gcov All code covered by tests in src/mpi/romio/mpi-io/get_bytoff.c.gcov All code covered by tests in src/mpi/romio/mpi-io/write_at.c.gcov All code covered by tests in src/mpi/romio/mpi-io/write_atall.c.gcov Uncovered lines in src/mpi/romio/mpi-io/get_view.c.gcov 103: -: 81: re-implement MPI_Type_contiguous in an unexpected way. Either use 104: -: 82: NMPI_Barrier as in MPICH2 or PMPI_Type_contiguous */ 105: #####: 83: MPI_Type_contiguous(1, fh->etype, ©_etype); 107: -: 84: 108: -: 85: /* FIXME: Ditto for MPI_Type_commit - use NMPI or PMPI */ 109: #####: 86: MPI_Type_commit(©_etype); 110: call 0 never executed 111: #####: 87: *etype = copy_etype; 3 line(s) not covered by tests in src/mpi/romio/mpi-io/get_view.c.gcov All code covered by tests in src/mpi/romio/mpi-io/get_group.c.gcov All code covered by tests in src/mpi/romio/mpi-io/get_amode.c.gcov All code covered by tests in src/mpi/romio/mpi-io/get_extent.c.gcov All code covered by tests in src/mpi/romio/mpi-io/fsync.c.gcov All code covered by tests in src/mpi/romio/mpi-io/get_atom.c.gcov Uncovered lines in src/mpi/romio/mpi-io/set_atom.c.gcov 95: branch 0 taken 0% (fallthrough) 96: branch 1 taken 100% 97: #####: 71: error_code = MPI_SUCCESS; 98: #####: 72: goto fn_exit; 2 line(s) not covered by tests in src/mpi/romio/mpi-io/set_atom.c.gcov All code covered by tests in src/mpi/romio/mpi-io/set_size.c.gcov All code covered by tests in src/mpi/romio/mpi-io/get_size.c.gcov All code covered by tests in src/mpi/romio/mpi-io/prealloc.c.gcov All code covered by tests in src/mpi/romio/mpi-io/file_f2c.c.gcov All code covered by tests in src/mpi/romio/mpi-io/file_c2f.c.gcov All code covered by tests in src/mpi/romio/mpi-io/set_info.c.gcov All code covered by tests in src/mpi/romio/mpi-io/get_info.c.gcov All code covered by tests in src/mpi/romio/mpi-io/rd_atallb.c.gcov All code covered by tests in src/mpi/romio/mpi-io/rd_atalle.c.gcov All code covered by tests in src/mpi/romio/mpi-io/read_allb.c.gcov All code covered by tests in src/mpi/romio/mpi-io/read_alle.c.gcov All code covered by tests in src/mpi/romio/mpi-io/wr_atallb.c.gcov All code covered by tests in src/mpi/romio/mpi-io/wr_atalle.c.gcov All code covered by tests in src/mpi/romio/mpi-io/write_allb.c.gcov All code covered by tests in src/mpi/romio/mpi-io/write_alle.c.gcov All code covered by tests in src/mpi/romio/mpi-io/get_posn_sh.c.gcov Uncovered lines in src/mpi/romio/mpi-io/iread_sh.c.gcov 157: -: 104: operations, lock (exclusive) and call blocking routine */ 158: -: 105: 159: #####: 106: if (fh->file_system != ADIO_NFS) 161: branch 1 never executed 162: -: 107: { 163: #####: 108: ADIOI_WRITE_LOCK(fh, off, SEEK_SET, bufsize); 165: -: 109: } 166: -: 110: 167: #####: 111: ADIO_ReadContig(fh, buf, count, datatype, ADIO_EXPLICIT_OFFSET, 169: -: 112: off, &status, &error_code); 170: -: 113: 171: #####: 114: if (fh->file_system != ADIO_NFS) 173: branch 1 never executed 174: -: 115: { 175: #####: 116: ADIOI_UNLOCK(fh, off, SEEK_SET, bufsize); 176: call 0 never executed 177: -: 117: } 178: #####: 118: if (error_code == MPI_SUCCESS){ 179: branch 0 never executed 180: branch 1 never executed 181: #####: 119: nbytes = count * datatype_size; 182: -: 120: } 183: #####: 121: MPIO_Completed_request_create(&fh, nbytes, &error_code, request); 187: -: 124: else 188: -: 125: { 189: #####: 126: ADIO_IreadStrided(fh, buf, count, datatype, ADIO_EXPLICIT_OFFSET, 9 line(s) not covered by tests in src/mpi/romio/mpi-io/iread_sh.c.gcov Uncovered lines in src/mpi/romio/mpi-io/read_sh.c.gcov 171: branch 2 never executed 172: branch 3 never executed 173: #####: 112: ADIOI_WRITE_LOCK(fh, off, SEEK_SET, bufsize); 183: branch 2 never executed 184: branch 3 never executed 185: #####: 118: ADIOI_UNLOCK(fh, off, SEEK_SET, bufsize); 188: -: 120: else 189: -: 121: { 190: #####: 122: ADIO_ReadStrided(fh, buf, count, datatype, ADIO_EXPLICIT_OFFSET, 3 line(s) not covered by tests in src/mpi/romio/mpi-io/read_sh.c.gcov Uncovered lines in src/mpi/romio/mpi-io/write_sh.c.gcov 168: branch 2 never executed 169: branch 3 never executed 170: #####: 112: ADIOI_WRITE_LOCK(fh, off, SEEK_SET, bufsize); 180: branch 2 never executed 181: branch 3 never executed 182: #####: 118: ADIOI_UNLOCK(fh, off, SEEK_SET, bufsize); 185: -: 120: else 186: -: 121: { 187: #####: 122: ADIO_WriteStrided(fh, buf, count, datatype, ADIO_EXPLICIT_OFFSET, 3 line(s) not covered by tests in src/mpi/romio/mpi-io/write_sh.c.gcov Uncovered lines in src/mpi/romio/mpi-io/iwrite_sh.c.gcov 126: branch 1 taken 100% 127: -: 82: /* note: ADIO_Get_shared_fp should have set up error code already? */ 128: #####: 83: MPIO_Err_return_file(fh, error_code); 149: -: 96: operations, lock (exclusive) and call blocking routine */ 150: -: 97: 151: #####: 98: if (fh->file_system != ADIO_NFS) 152: branch 0 never executed 153: branch 1 never executed 154: #####: 99: ADIOI_WRITE_LOCK(fh, off, SEEK_SET, bufsize); 155: call 0 never executed 156: -: 100: 157: #####: 101: ADIO_WriteContig(fh, buf, count, datatype, ADIO_EXPLICIT_OFFSET, 159: -: 102: off, &status, &error_code); 160: -: 103: 161: #####: 104: if (fh->file_system != ADIO_NFS) 162: branch 0 never executed 163: branch 1 never executed 164: #####: 105: ADIOI_UNLOCK(fh, off, SEEK_SET, bufsize); 165: call 0 never executed 166: -: 106: 167: #####: 107: MPIO_Completed_request_create(&fh, bufsize, &error_code, request); 170: -: 109: } 171: -: 110: else 172: #####: 111: ADIO_IwriteStrided(fh, buf, count, datatype, ADIO_EXPLICIT_OFFSET, 8 line(s) not covered by tests in src/mpi/romio/mpi-io/iwrite_sh.c.gcov Uncovered lines in src/mpi/romio/mpi-io/seek_sh.c.gcov 150: -: 102: case MPI_SEEK_CUR: 151: -: 103: /* get current location of shared file pointer */ 152: #####: 104: ADIO_Get_shared_fp(fh, 0, &curr_offset, &error_code); 168: #####: 104: ADIO_Get_shared_fp(fh, 0, &curr_offset, &error_code); 169: call 0 never executed 170: #####: 117: offset += curr_offset; 188: -: 131: case MPI_SEEK_END: 189: -: 132: /* find offset corr. to end of file */ 190: #####: 133: ADIOI_Get_eof_offset(fh, &eof_offset); 191: call 0 never executed 192: #####: 134: offset += eof_offset; 4 line(s) not covered by tests in src/mpi/romio/mpi-io/seek_sh.c.gcov All code covered by tests in src/mpi/romio/mpi-io/read_ord.c.gcov All code covered by tests in src/mpi/romio/mpi-io/read_orde.c.gcov All code covered by tests in src/mpi/romio/mpi-io/write_ordb.c.gcov All code covered by tests in src/mpi/romio/mpi-io/read_ordb.c.gcov All code covered by tests in src/mpi/romio/mpi-io/write_ord.c.gcov All code covered by tests in src/mpi/romio/mpi-io/write_orde.c.gcov Uncovered lines in src/mpi/romio/mpi-io/mpiu_greq.c.gcov 56: -: 44:int MPIU_Greq_cancel_fn(void *extra_state, int complete) 57: function MPIU_Greq_cancel_fn called 0 returned 0% blocks executed 0% 58: #####: 45:{ 61: -: 48: 62: -: 49: /* can't cancel */ 63: #####: 50: return MPI_SUCCESS; 2 line(s) not covered by tests in src/mpi/romio/mpi-io/mpiu_greq.c.gcov All code covered by tests in src/mpi/romio/mpi-io/mpich2_fileutil.c.gcov Uncovered lines in src/mpi/romio/mpi-io/register_datarep.c.gcov 60: -: 55: void *state) 61: function PMPI_Register_datarep called 0 returned 0% blocks executed 0% 62: #####: 56:{ 94: -: 63: 95: -: 80: 96: #####: 81: MPIR_MPIOInit(&error_code); 97: call 0 never executed 98: #####: 82: if (error_code != MPI_SUCCESS) goto fn_exit; 140: -: 83: 141: -: 112: 142: #####: 113: datarep = ADIOI_Malloc(sizeof(ADIOI_Datarep)); 146: -: 116: ifdef MPICH2 */ 147: -: 117:#ifdef MPICH2 148: #####: 118: datarep->name = MPIU_Strdup(name); 151: -: 120: datarep->name = ADIOI_Strdup(name); 152: -: 121:#endif 153: #####: 122: datarep->state = state; 154: #####: 123: datarep->read_conv_fn = read_conv_fn; 155: #####: 124: datarep->write_conv_fn = write_conv_fn; 156: #####: 125: datarep->extent_fn = extent_fn; 157: #####: 126: datarep->next = ADIOI_Datarep_head; 158: -: 127: 159: #####: 128: ADIOI_Datarep_head = datarep; 160: -: 129: 161: #####: 130: error_code = MPI_SUCCESS; 162: -: 131: 163: #####: 132:fn_exit: 164: -: 133: MPIU_THREAD_CS_EXIT(ALLFUNC,); 165: -: 134: 166: #####: 135: return error_code; 14 line(s) not covered by tests in src/mpi/romio/mpi-io/register_datarep.c.gcov All code covered by tests in src/mpi/romio/mpi-io/mpir-mpioinit.c.gcov All code covered by tests in src/mpi/attr/attr_delete.c.gcov All code covered by tests in src/mpi/attr/attr_get.c.gcov All code covered by tests in src/mpi/attr/attr_put.c.gcov All code covered by tests in src/mpi/attr/comm_create_keyval.c.gcov All code covered by tests in src/mpi/attr/comm_delete_attr.c.gcov Uncovered lines in src/mpi/attr/comm_get_attr.c.gcov 208: branch 1 taken 100% 209: -: 148: { 210: #####: 149: *attr_val_p = &attr_copy.universe; 214: branch 1 taken 100% 215: -: 152: { 216: #####: 153: *flag = 0; 238: -: 170: else 239: -: 171: { 240: #####: 172: attr_copy.universe = MPIR_UNIVERSE_SIZE_NOT_AVAILABLE; 241: #####: 173: *flag = 0; 255: branch 0 taken 0% (fallthrough) 256: branch 1 taken 100% 257: #####: 187: *flag = 0; 303: -: 219: correct location in the word. */ 304: -: 220:#if defined(WORDS_LITTLEENDIAN) || (SIZEOF_VOID_P == SIZEOF_INT) 305: #####: 221: *(void**)attribute_val = &(p->value); 6 line(s) not covered by tests in src/mpi/attr/comm_get_attr.c.gcov All code covered by tests in src/mpi/attr/comm_set_attr.c.gcov All code covered by tests in src/mpi/attr/keyval_free.c.gcov All code covered by tests in src/mpi/attr/type_create_keyval.c.gcov All code covered by tests in src/mpi/attr/type_free_keyval.c.gcov All code covered by tests in src/mpi/attr/type_set_attr.c.gcov All code covered by tests in src/mpi/attr/win_create_keyval.c.gcov All code covered by tests in src/mpi/attr/win_free_keyval.c.gcov All code covered by tests in src/mpi/attr/win_set_attr.c.gcov Uncovered lines in src/mpi/attr/attrutil.c.gcov 365: branch 0 taken 0% (fallthrough) 366: branch 1 taken 100% 367: #####: 306: attrib_val = &attrib; 391: branch 0 taken 0% (fallthrough) 392: branch 1 taken 100% 393: #####: 328: attrib_val = &attrib; 417: branch 0 taken 0% (fallthrough) 418: branch 1 taken 100% 419: #####: 345: return; 3 line(s) not covered by tests in src/mpi/attr/attrutil.c.gcov All code covered by tests in src/mpi/attr/comm_free_keyval.c.gcov All code covered by tests in src/mpi/attr/keyval_create.c.gcov All code covered by tests in src/mpi/attr/type_delete_attr.c.gcov Uncovered lines in src/mpi/attr/type_get_attr.c.gcov 145: -: 99: correct location in the word. */ 146: -: 100:#if defined(WORDS_LITTLEENDIAN) || (SIZEOF_VOID_P == SIZEOF_INT) 147: #####: 101: *(void**)attribute_val = &(p->value); 159: branch 0 taken 0% (fallthrough) 160: branch 1 taken 100% 161: #####: 113: *(void**)attribute_val = &(p->value); 2 line(s) not covered by tests in src/mpi/attr/type_get_attr.c.gcov All code covered by tests in src/mpi/attr/win_delete_attr.c.gcov Uncovered lines in src/mpi/attr/win_get_attr.c.gcov 213: -: 153: correct location in the word. */ 214: -: 154:#if defined(WORDS_LITTLEENDIAN) || (SIZEOF_VOID_P == SIZEOF_INT) 215: #####: 155: *(void**)attribute_val = &(p->value); 227: branch 0 taken 0% (fallthrough) 228: branch 1 taken 100% 229: #####: 167: *(void**)attribute_val = &(p->value); 2 line(s) not covered by tests in src/mpi/attr/win_get_attr.c.gcov All code covered by tests in src/mpi/attr/dup_fn.c.gcov Uncovered lines in src/mpi/coll/allreduce.c.gcov 202: 3451: 181: uop = (MPI_User_function *) op_ptr->function.c_function; 203: -: 182: else 204: #####: 183: uop = (MPI_User_function *) op_ptr->function.f77_function; 459: branch 0 taken 0% 460: branch 1 taken 100% (fallthrough) 461: #####: 341: cnts[i] = count/pof2; 466: branch 0 taken 0% 467: branch 1 taken 100% (fallthrough) 468: #####: 346: disps[i] = disps[i-1] + cnts[i-1]; 474: branch 0 taken 0% 475: branch 1 taken 100% (fallthrough) 476: #####: 352: newdst = newrank ^ mask; 477: -: 353: /* find real rank of dest */ 478: #####: 354: dst = (newdst < rem) ? newdst*2 + 1 : newdst + rem; 480: branch 1 never executed 481: -: 355: 482: #####: 356: send_cnt = recv_cnt = 0; 483: #####: 357: if (newrank < newdst) { 484: branch 0 never executed 485: branch 1 never executed 486: #####: 358: send_idx = recv_idx + pof2/(mask*2); 487: #####: 359: for (i=send_idx; i newdst) send_idx = recv_idx; 612: branch 1 never executed 613: -: 448: 614: #####: 449: mask >>= 1; 648: branch 0 taken 0% (fallthrough) 649: branch 1 taken 100% 650: #####: 474: mpi_errno = MPIU_THREADPRIV_FIELD(op_errno); 750: branch 0 taken 0% (fallthrough) 751: branch 1 taken 100% 752: #####: 548: MPIR_Setup_intercomm_localcomm( comm_ptr ); 1025: branch 3 never executed 1026: -: 676: { 1027: #####: 677: mpi_errno = comm_ptr->coll_fns->Allreduce(sendbuf, recvbuf, count, 1092: -: 717: else { 1093: -: 718: /* only one process on the node. copy sendbuf to recvbuf */ 1094: #####: 719: if (sendbuf != MPI_IN_PLACE) { 1095: branch 0 never executed 1096: branch 1 never executed 1097: #####: 720: mpi_errno = MPIR_Localcopy(sendbuf, count, datatype, 49 line(s) not covered by tests in src/mpi/coll/allreduce.c.gcov Uncovered lines in src/mpi/coll/barrier.c.gcov 490: branch 3 never executed 491: -: 407: { 492: #####: 408: mpi_errno = comm_ptr->coll_fns->Barrier(comm_ptr); 516: branch 0 taken 0% (fallthrough) 517: branch 1 taken 100% 518: #####: 423: MPIR_Nest_decr(); 530: branch 0 taken 0% (fallthrough) 531: branch 1 taken 100% 532: #####: 432: MPIR_Nest_decr(); 3 line(s) not covered by tests in src/mpi/coll/barrier.c.gcov All code covered by tests in src/mpi/coll/op_create.c.gcov All code covered by tests in src/mpi/coll/op_free.c.gcov Uncovered lines in src/mpi/coll/bcast.c.gcov 52: branch 4 taken 0% (fallthrough) 53: branch 5 taken 100% 54: #####: 37: *ceil_pof2 = pof2; 139: -: 99: } 140: -: 100: else { 141: #####: 101: mpi_errno = NMPI_Pack_size(1, datatype, comm, &type_size); 381: branch 1 taken 100% 382: -: 274: { 383: #####: 275: curr_size = 0; /* this process doesn't receive any data 510: branch 1 taken 100% 511: -: 381: 512: #####: 382: if (HANDLE_GET_KIND(datatype) == HANDLE_KIND_BUILTIN) 513: branch 0 never executed 514: branch 1 never executed 515: #####: 383: is_contig = 1; 516: -: 384: else { 517: #####: 385: MPID_Datatype_get_ptr(datatype, dtp); 521: branch 3 never executed 522: call 4 never executed 523: #####: 386: is_contig = dtp->is_contig; 524: -: 387: } 525: -: 388: 526: #####: 389: is_homogeneous = 1; 537: -: 400: * possible, and MPI_Pack_size() in other places. 538: -: 401: */ 539: #####: 402: if (is_homogeneous) { 540: branch 0 never executed 541: branch 1 never executed 542: #####: 403: MPID_Datatype_get_size_macro(datatype, type_size); 548: -: 404: } 549: -: 405: else { 550: #####: 406: mpi_errno = NMPI_Pack_size(1, datatype, comm, &type_size); 555: call 2 never executed 556: -: 408: } 557: #####: 409: nbytes = type_size * count; 558: -: 410: 559: #####: 411: if (is_contig && is_homogeneous) 562: -: 412: { 563: -: 413: /* contiguous and homogeneous. no need to pack. */ 564: #####: 414: mpi_errno = NMPI_Type_get_true_extent(datatype, &true_lb, 570: call 2 never executed 571: -: 417: 572: #####: 418: tmp_buf = (char *) buffer + true_lb; 574: -: 420: else 575: -: 421: { 576: #####: 422: MPIU_CHKLMEM_MALLOC(tmp_buf, void *, nbytes, mpi_errno, "tmp_buf"); 587: -: 423: 588: -: 424: /* TODO: Pipeline the packing and communication */ 589: #####: 425: position = 0; 590: #####: 426: if (rank == root) 591: branch 0 never executed 592: branch 1 never executed 593: #####: 427: NMPI_Pack(buffer, count, datatype, tmp_buf, nbytes, 597: -: 430: 598: -: 431: 599: #####: 432: scatter_size = (nbytes + comm_size - 1)/comm_size; /* ceiling division */ 600: #####: 433: curr_size = (rank == root) ? nbytes : 0; /* root starts with all the 604: -: 435: 605: -: 436: 606: #####: 437: mpi_errno = scatter_for_bcast(buffer, count, datatype, root, comm_ptr, 614: -: 441: /* medium size allgather and pof2 comm_size. use recurive doubling. */ 615: -: 442: 616: #####: 443: mask = 0x1; 617: #####: 444: i = 0; 618: #####: 445: while (mask < comm_size) 620: branch 1 never executed 621: -: 446: { 622: #####: 447: relative_dst = relative_rank ^ mask; 623: -: 448: 624: #####: 449: dst = (relative_dst + root) % comm_size; 630: -: 455: and recv into buffer */ 631: -: 456: 632: #####: 457: dst_tree_root = relative_dst >> i; 633: #####: 458: dst_tree_root <<= i; 634: -: 459: 635: #####: 460: my_tree_root = relative_rank >> i; 636: #####: 461: my_tree_root <<= i; 637: -: 462: 638: #####: 463: send_offset = my_tree_root * scatter_size; 639: #####: 464: recv_offset = dst_tree_root * scatter_size; 640: -: 465: 641: #####: 466: if (relative_dst < comm_size) 643: branch 1 never executed 644: -: 467: { 645: #####: 468: mpi_errno = MPIC_Sendrecv(((char *)tmp_buf + send_offset), 654: call 2 never executed 655: -: 474: 656: #####: 475: NMPI_Get_count(&status, MPI_BYTE, &recv_size); 657: call 0 never executed 658: #####: 476: curr_size += recv_size; 779: -: 491: 780: -: 571: 781: #####: 572: mask <<= 1; 782: #####: 573: i++; 783: -: 574: } 784: -: 575: 785: #####: 576: if (!is_contig || !is_homogeneous) 787: branch 1 never executed 788: -: 577: { 789: #####: 578: if (rank != root) 791: branch 1 never executed 792: -: 579: { 793: #####: 580: position = 0; 794: #####: 581: NMPI_Unpack(tmp_buf, nbytes, &position, buffer, count, 799: -: 585: 800: -: 586:fn_exit: 801: #####: 587: MPIU_CHKLMEM_FREEALL(); 899: -: 663: } 900: -: 664: else { 901: #####: 665: mpi_errno = NMPI_Pack_size(1, datatype, comm, &type_size); 994: branch 0 taken 0% (fallthrough) 995: branch 1 taken 100% 996: #####: 707: recvcnts[i] = 0; 1130: -: 812: } 1131: -: 813: else { 1132: #####: 814: mpi_errno = NMPI_Pack_size(1, datatype, comm_ptr->handle, &type_size); 1284: -: 884: else 1285: -: 885: { 1286: #####: 886: MPIR_Bcast_fn_or_override(MPIR_Bcast_scatter_ring_allgather, mpi_errno, 1467: -: 1021: } 1468: -: 1022: else { 1469: #####: 1023: mpi_errno = NMPI_Pack_size(1, datatype, comm, &type_size); 1489: -: 1033: else /* (nbytes >= MPIR_BCAST_SHORT_MSG) && (comm_size >= MPIR_BCAST_MIN_PROCS) */ 1490: -: 1034: { 1491: #####: 1035: if ((nbytes < MPIR_BCAST_LONG_MSG) && (MPIU_is_pof2(comm_size, NULL))) 1495: branch 3 never executed 1496: -: 1036: { 1497: #####: 1037: mpi_errno = MPIR_Bcast_scatter_doubling_allgather(buffer, count, datatype, root, comm_ptr); 1507: -: 1043: topologically aware communicator. Doing inter/intra-node 1508: -: 1044: communication phases breaks the pipelining of the algorithm. */ 1509: #####: 1045: mpi_errno = MPIR_Bcast_scatter_ring_allgather(buffer, count, datatype, root, comm_ptr); 52 line(s) not covered by tests in src/mpi/coll/bcast.c.gcov Uncovered lines in src/mpi/coll/alltoall.c.gcov 1033: branch 3 never executed 1034: -: 724: { 1035: #####: 725: mpi_errno = comm_ptr->coll_fns->Alltoall(sendbuf, sendcount, 1 line(s) not covered by tests in src/mpi/coll/alltoall.c.gcov Uncovered lines in src/mpi/coll/alltoallv.c.gcov 686: branch 3 never executed 687: -: 421: { 688: #####: 422: mpi_errno = comm_ptr->coll_fns->Alltoallv(sendbuf, sendcnts, sdispls, 1 line(s) not covered by tests in src/mpi/coll/alltoallv.c.gcov Uncovered lines in src/mpi/coll/reduce.c.gcov 123: 10622: 94: uop = (MPI_User_function *) op_ptr->function.c_function; 124: -: 95: else 125: #####: 96: uop = (MPI_User_function *) op_ptr->function.f77_function; 269: branch 0 taken 0% (fallthrough) 270: branch 1 taken 100% 271: #####: 189: (*MPIR_Process.cxx_call_op_fn)( recvbuf, tmp_buf, 437: -: 318: } 438: -: 319: else { 439: #####: 320: MPID_Op_get_ptr(op, op_ptr); 443: branch 3 never executed 444: call 4 never executed 445: #####: 321: if (op_ptr->kind == MPID_OP_USER_NONCOMMUTE) 446: branch 0 never executed 447: branch 1 never executed 448: #####: 322: is_commutative = 0; 449: -: 323: else 450: #####: 324: is_commutative = 1; 451: -: 325: 452: -: 326:#ifdef HAVE_CXX_BINDING 453: #####: 327: if (op_ptr->language == MPID_LANG_CXX) { 454: branch 0 never executed 455: branch 1 never executed 456: #####: 328: uop = (MPI_User_function *) op_ptr->function.c_function; 457: #####: 329: is_cxx_uop = 1; 459: -: 331: else 460: -: 332:#endif 461: #####: 333: if ((op_ptr->language == MPID_LANG_C)) 462: branch 0 never executed 463: branch 1 never executed 464: #####: 334: uop = (MPI_User_function *) op_ptr->function.c_function; 465: -: 335: else 466: #####: 336: uop = (MPI_User_function *) op_ptr->function.f77_function; 590: branch 0 taken 0% (fallthrough) 591: branch 1 taken 100% 592: #####: 413: (*MPIR_Process.cxx_call_op_fn)( tmp_buf, recvbuf, 719: branch 0 taken 0% (fallthrough) 720: branch 1 taken 100% 721: #####: 494: (*MPIR_Process.cxx_call_op_fn)((char *) tmp_buf + 1697: branch 3 never executed 1698: -: 1068: { 1699: #####: 1069: mpi_errno = comm_ptr->coll_fns->Reduce(sendbuf, recvbuf, count, 1782: branch 4 taken 100% 1783: -: 1113: MPIU_Get_intranode_rank(comm_ptr, root) == -1) { 1784: #####: 1114: mpi_errno = MPIR_Reduce_or_coll_fn(sendbuf, tmp_buf, count, datatype, 1800: -: 1122: /* I am not on root's node. Use tmp_buf if we 1801: -: 1123: participated in the first reduce, otherwise use sendbuf */ 1802: #####: 1124: void *buf = (comm_ptr->node_comm == NULL ? sendbuf : tmp_buf); 1803: branch 0 never executed 1804: branch 1 never executed 1805: #####: 1125: mpi_errno = MPIR_Reduce(buf, NULL, count, datatype, 18 line(s) not covered by tests in src/mpi/coll/reduce.c.gcov Uncovered lines in src/mpi/coll/scatter.c.gcov 1148: branch 3 never executed 1149: -: 728: { 1150: #####: 729: mpi_errno = comm_ptr->coll_fns->Scatter(sendbuf, sendcnt, 1 line(s) not covered by tests in src/mpi/coll/scatter.c.gcov Uncovered lines in src/mpi/coll/gather.c.gcov 1154: branch 3 never executed 1155: -: 722: { 1156: #####: 723: mpi_errno = comm_ptr->coll_fns->Gather(sendbuf, sendcnt, 1 line(s) not covered by tests in src/mpi/coll/gather.c.gcov Uncovered lines in src/mpi/coll/scatterv.c.gcov 653: branch 3 never executed 654: -: 314: { 655: #####: 315: mpi_errno = comm_ptr->coll_fns->Scatterv(sendbuf, sendcnts, displs, 1 line(s) not covered by tests in src/mpi/coll/scatterv.c.gcov Uncovered lines in src/mpi/coll/gatherv.c.gcov 202: branch 0 taken 0% (fallthrough) 203: branch 1 taken 100% 204: #####: 139: min_procs = comm_size + 1; /* Disable ssend */ 206: branch 0 taken 0% (fallthrough) 207: branch 1 taken 100% 208: #####: 141: min_procs = MPIR_GATHERV_MIN_PROCS; /* Use the default value */ 211: branch 0 taken 0% (fallthrough) 212: branch 1 taken 100% 213: #####: 144: mpi_errno = MPIC_Ssend(sendbuf, sendcnt, sendtype, root, 677: branch 3 never executed 678: -: 332: { 679: #####: 333: mpi_errno = comm_ptr->coll_fns->Gatherv(sendbuf, sendcnt, 4 line(s) not covered by tests in src/mpi/coll/gatherv.c.gcov Uncovered lines in src/mpi/coll/stdlib.h.gcov 289: -: 284:__NTH (atoi (__const char *__nptr)) 290: -: 285:{ 291: #####: 286: return (int) strtol (__nptr, (char **) NULL, 10); 1 line(s) not covered by tests in src/mpi/coll/stdlib.h.gcov Uncovered lines in src/mpi/coll/scan.c.gcov 139: 4962: 118: uop = (MPI_User_function *) op_ptr->function.c_function; 140: -: 119: else 141: #####: 120: uop = (MPI_User_function *) op_ptr->function.f77_function; 223: -: 177: partial_scan, count, datatype); 224: -: 178: else 225: #####: 179: mpi_errno = MPIR_Localcopy(recvbuf, count, datatype, 311: branch 0 taken 0% (fallthrough) 312: branch 1 taken 100% 313: #####: 239: (*MPIR_Process.cxx_call_op_fn)( partial_scan, tmp_buf, 350: branch 0 taken 0% (fallthrough) 351: branch 1 taken 100% 352: #####: 268: mpi_errno = MPIU_THREADPRIV_FIELD(op_errno); 504: call 2 never executed 505: -: 365: } 506: #####: 366: else if (sendbuf != MPI_IN_PLACE) 508: branch 1 never executed 509: -: 367: { 510: #####: 368: mpi_errno = MPIR_Localcopy(sendbuf, count, datatype, 559: branch 1 taken 100% 560: -: 393: { 561: #####: 394: localfulldata = recvbuf; 584: -: 408: comm_ptr->node_roots_comm->local_size-1) 585: -: 409: { 586: #####: 410: mpi_errno = MPIC_Send(prefulldata, count, datatype, 599: branch 2 taken 100% 600: -: 416: { 601: #####: 417: mpi_errno = MPIC_Recv(tempbuf, count, datatype, 605: -: 419: MPIR_SCAN_TAG, comm_ptr->node_roots_comm->handle, 606: -: 420: &status); 607: #####: 421: noneed = 0; 634: branch 1 taken 100% 635: -: 438:#ifdef HAVE_CXX_BINDING 636: #####: 439: int is_cxx_uop = 0; 637: -: 440:#endif 638: #####: 441: if (comm_ptr->node_comm != NULL) { 639: branch 0 never executed 640: branch 1 never executed 641: #####: 442: mpi_errno = MPIR_Bcast_or_coll_fn(tempbuf, count, datatype, 0, comm_ptr->node_comm); 648: -: 445: 649: -: 446: /* do reduce on tempbuf and recvbuf, finish scan. */ 650: #####: 447: if (HANDLE_GET_KIND(op) == HANDLE_KIND_BUILTIN) { 652: branch 1 never executed 653: -: 448: /* get the function by indexing into the op table */ 654: #####: 449: uop = MPIR_Op_table[op%16 - 1]; 655: -: 450: } 656: -: 451: else { 657: #####: 452: MPID_Op_get_ptr(op, op_ptr); 663: -: 453: 664: -: 454:#ifdef HAVE_CXX_BINDING 665: #####: 455: if (op_ptr->language == MPID_LANG_CXX) { 666: branch 0 never executed 667: branch 1 never executed 668: #####: 456: uop = (MPI_User_function *) op_ptr->function.c_function; 669: #####: 457: is_cxx_uop = 1; 672: -: 460:#endif 673: -: 461: { 674: #####: 462: if ((op_ptr->language == MPID_LANG_C)) 675: branch 0 never executed 676: branch 1 never executed 677: #####: 463: uop = (MPI_User_function *) op_ptr->function.c_function; 678: -: 464: else 679: #####: 465: uop = (MPI_User_function *) op_ptr->function.f77_function; 682: -: 468: 683: -: 469:#ifdef HAVE_CXX_BINDING 684: #####: 470: if (is_cxx_uop) { 685: branch 0 never executed 686: branch 1 never executed 687: #####: 471: (*MPIR_Process.cxx_call_op_fn)( tempbuf, recvbuf, count, 691: -: 474: else 692: -: 475:#endif 693: #####: 476: (*uop)(tempbuf, recvbuf, &count, &datatype); 946: branch 3 never executed 947: -: 594: { 948: #####: 595: mpi_errno = comm_ptr->coll_fns->Scan(sendbuf, recvbuf, count, 26 line(s) not covered by tests in src/mpi/coll/scan.c.gcov Uncovered lines in src/mpi/coll/exscan.c.gcov 149: branch 0 taken 0% (fallthrough) 150: branch 1 taken 100% 151: #####: 134: is_commutative = 0; 162: -: 143: else 163: -: 144:#endif 164: #####: 145: if ((op_ptr->language == MPID_LANG_C)) 165: branch 0 never executed 166: branch 1 never executed 167: #####: 146: uop = (MPI_User_function *) op_ptr->function.c_function; 168: -: 147: else 169: #####: 148: uop = (MPI_User_function *) op_ptr->function.f77_function; 300: -: 213: } 301: -: 214: else { 302: #####: 215: call_uop(partial_scan, tmp_buf, count, datatype); 306: call 3 never executed 307: -: 216: 308: #####: 217: mpi_errno = MPIR_Localcopy(tmp_buf, count, datatype, 326: branch 0 taken 0% (fallthrough) 327: branch 1 taken 100% 328: #####: 231: mpi_errno = MPIU_THREADPRIV_FIELD(op_errno); 591: branch 3 never executed 592: -: 358: { 593: #####: 359: mpi_errno = comm_ptr->coll_fns->Exscan(sendbuf, recvbuf, count, 8 line(s) not covered by tests in src/mpi/coll/exscan.c.gcov Uncovered lines in src/mpi/coll/allgather.c.gcov 1156: branch 3 never executed 1157: -: 823: { 1158: #####: 824: mpi_errno = comm_ptr->coll_fns->Allgather(sendbuf, sendcount, 1 line(s) not covered by tests in src/mpi/coll/allgather.c.gcov Uncovered lines in src/mpi/coll/allgatherv.c.gcov 889: branch 0 taken 0% (fallthrough) 890: branch 1 taken 100% 891: #####: 735: min = 1; 1417: branch 3 never executed 1418: -: 1057: { 1419: #####: 1058: mpi_errno = comm_ptr->coll_fns->Allgatherv(sendbuf, sendcount, 2 line(s) not covered by tests in src/mpi/coll/allgatherv.c.gcov Uncovered lines in src/mpi/coll/red_scat.c.gcov 125: branch 0 taken 0% (fallthrough) 126: branch 1 taken 100% 127: #####: 112: is_commutative = 1; 128: -: 113: /* get the function by indexing into the op table */ 129: #####: 114: uop = MPIR_Op_table[op%16 - 1]; 141: 1956: 119: is_commutative = 0; 142: -: 120: else 143: #####: 121: is_commutative = 1; 147: branch 0 taken 0% (fallthrough) 148: branch 1 taken 100% 149: #####: 125: uop = (MPI_User_function *) op_ptr->function.c_function; 150: #####: 126: is_cxx_uop = 1; 157: 1956: 131: uop = (MPI_User_function *) op_ptr->function.c_function; 158: -: 132: else 159: #####: 133: uop = (MPI_User_function *) op_ptr->function.f77_function; 453: branch 0 taken 0% (fallthrough) 454: branch 1 taken 100% 455: #####: 340: uop = (MPI_User_function *) op_ptr->function.c_function; 456: #####: 341: is_cxx_uop = 1; 463: 4176: 346: uop = (MPI_User_function *) op_ptr->function.c_function; 464: -: 347: else 465: #####: 348: uop = (MPI_User_function *) op_ptr->function.f77_function; 489: branch 0 taken 0% (fallthrough) 490: branch 1 taken 100% 491: #####: 360: goto fn_exit; 624: branch 0 taken 0% (fallthrough) 625: branch 1 taken 100% 626: #####: 445: (*MPIR_Process.cxx_call_op_fn)( tmp_recvbuf, tmp_results, 752: -: 522: MPIR_REDUCE_SCATTER_TAG, comm, 753: -: 523: MPI_STATUS_IGNORE); 754: #####: 524: else if ((send_cnt == 0) && (recv_cnt != 0)) 755: branch 0 never executed 756: branch 1 never executed 757: #####: 525: mpi_errno = MPIC_Recv((char *) tmp_recvbuf + 761: -: 528: MPIR_REDUCE_SCATTER_TAG, comm, 762: -: 529: MPI_STATUS_IGNORE); 763: #####: 530: else if ((recv_cnt == 0) && (send_cnt != 0)) 764: branch 0 never executed 765: branch 1 never executed 766: #####: 531: mpi_errno = MPIC_Send((char *) tmp_results + 786: branch 0 taken 0% (fallthrough) 787: branch 1 taken 100% 788: #####: 545: (*MPIR_Process.cxx_call_op_fn)((char *) tmp_recvbuf + 866: -: 600: use (p-1) pairwise exchanges */ 867: -: 601: 868: #####: 602: if (sendbuf != MPI_IN_PLACE) { 870: branch 1 never executed 871: -: 603: /* copy local data into recvbuf */ 872: #####: 604: mpi_errno = MPIR_Localcopy(((char *)sendbuf+disps[rank]*extent), 881: -: 609: 882: -: 610: /* allocate temporary buffer to store incoming data */ 883: #####: 611: MPIU_CHKLMEM_MALLOC(tmp_recvbuf, void *, recvcnts[rank]*(MPIR_MAX(true_extent,extent))+1, mpi_errno, "tmp_recvbuf"); 893: call 9 never executed 894: -: 612: /* adjust for potential negative lower bound in datatype */ 895: #####: 613: tmp_recvbuf = (void *)((char*)tmp_recvbuf - true_lb); 896: -: 614: 897: #####: 615: for (i=1; irank; 1448: #####: 1001: local_size = comm_ptr->local_size; 1449: -: 1002: 1450: #####: 1003: total_count = 0; 1451: #####: 1004: for (i=0; iis_low_group) { 1519: branch 1 never executed 1520: -: 1049: /* reduce from right group to rank 0*/ 1521: #####: 1050: root = (rank == 0) ? MPI_ROOT : MPI_PROC_NULL; 1522: branch 0 never executed 1523: branch 1 never executed 1524: #####: 1051: mpi_errno = MPIR_Reduce_inter(sendbuf, tmp_buf, total_count, datatype, op, 1537: -: 1060: 1538: -: 1061: /* reduce to rank 0 of right group */ 1539: #####: 1062: root = 0; 1540: #####: 1063: mpi_errno = MPIR_Reduce_inter(sendbuf, tmp_buf, total_count, datatype, op, 1554: -: 1073: else { 1555: -: 1074: /* reduce to rank 0 of left group */ 1556: #####: 1075: root = 0; 1557: #####: 1076: mpi_errno = MPIR_Reduce_inter(sendbuf, tmp_buf, total_count, datatype, op, 1570: -: 1085: 1571: -: 1086: /* reduce from right group to rank 0 */ 1572: #####: 1087: root = (rank == 0) ? MPI_ROOT : MPI_PROC_NULL; 1573: branch 0 never executed 1574: branch 1 never executed 1575: #####: 1088: mpi_errno = MPIR_Reduce_inter(sendbuf, tmp_buf, total_count, datatype, op, 1589: -: 1098: 1590: -: 1099: /* Get the local intracommunicator */ 1591: #####: 1100: if (!comm_ptr->local_comm) 1592: branch 0 never executed 1593: branch 1 never executed 1594: #####: 1101: MPIR_Setup_intercomm_localcomm( comm_ptr ); 1595: call 0 never executed 1596: -: 1102: 1597: #####: 1103: newcomm_ptr = comm_ptr->local_comm; 1598: -: 1104: 1599: #####: 1105: mpi_errno = MPIR_Scatterv(tmp_buf, recvcnts, disps, datatype, recvbuf, 1611: -: 1106: recvcnts[rank], datatype, 0, newcomm_ptr); 1612: -: 1114: 1613: #####: 1115: if (rank == 0) { 1614: branch 0 never executed 1615: branch 1 never executed 1616: #####: 1116: MPIU_Free(disps); 1617: call 0 never executed 1618: #####: 1117: MPIU_Free((char*)tmp_buf+true_lb); 1620: -: 1118: } 1621: -: 1119: 1622: #####: 1120: return mpi_errno; 1881: branch 3 never executed 1882: -: 1244: { 1883: #####: 1245: mpi_errno = comm_ptr->coll_fns->Reduce_scatter(sendbuf, recvbuf, 1901: -: 1259: else { 1902: -: 1260: /* intercommunicator */ 1903: #####: 1261: mpi_errno = MPIR_Reduce_scatter_inter(sendbuf, recvbuf, 91 line(s) not covered by tests in src/mpi/coll/red_scat.c.gcov Uncovered lines in src/mpi/coll/alltoallw.c.gcov 706: branch 3 never executed 707: -: 447: { 708: #####: 448: mpi_errno = comm_ptr->coll_fns->Alltoallw(sendbuf, sendcnts, sdispls, 1 line(s) not covered by tests in src/mpi/coll/alltoallw.c.gcov Uncovered lines in src/mpi/coll/reduce_local.c.gcov 164: branch 0 taken 0% (fallthrough) 165: branch 1 taken 100% 166: #####: 115: uop = (MPI_User_function *) op_ptr->function.c_function; 167: #####: 116: is_cxx_uop = 1; 175: 64: 122: uop = (MPI_User_function *) op_ptr->function.c_function; 176: -: 123: else 177: #####: 124: uop = (MPI_User_function *) op_ptr->function.f77_function; 184: branch 0 taken 0% (fallthrough) 185: branch 1 taken 100% 186: #####: 131: (*MPIR_Process.cxx_call_op_fn)(inbuf, inoutbuf, count, datatype, uop); 4 line(s) not covered by tests in src/mpi/coll/reduce_local.c.gcov Uncovered lines in src/mpi/coll/op_commutative.c.gcov 58: -: 53:int MPI_Op_commutative(MPI_Op op, int *commute) 59: function PMPI_Op_commutative called 0 returned 0% blocks executed 0% 60: #####: 54:{ 61: #####: 55: MPID_Op *op_ptr = NULL; 62: #####: 56: int mpi_errno = MPI_SUCCESS; 64: -: 58: MPID_MPI_STATE_DECL(MPID_STATE_MPI_OP_COMMUTATIVE); 65: -: 59: 66: #####: 60: MPIR_ERRTEST_INITIALIZED_ORDIE(); 72: -: 63: MPID_MPI_FUNC_ENTER(MPID_STATE_MPI_OP_COMMUTATIVE); 73: -: 64: 74: #####: 65: MPID_Op_get_ptr( op, op_ptr ); 98: -: 78: /* ... body of routine ... */ 99: -: 79: 100: #####: 80: if (HANDLE_GET_KIND(op) == HANDLE_KIND_BUILTIN) { 101: branch 0 never executed 102: branch 1 never executed 103: #####: 81: *commute = 1; 105: -: 83: } 106: -: 84: else { 107: #####: 85: if (op_ptr->kind == MPID_OP_USER_NONCOMMUTE) 108: branch 0 never executed 109: branch 1 never executed 110: #####: 86: *commute = 0; 111: -: 87: else 112: #####: 88: *commute = 1; 115: -: 91: /* ... end of body of routine ... */ 116: -: 92: 117: #####: 93:fn_exit: 118: #####: 93:fn_exit: 119: #####: 95: return mpi_errno; 12 line(s) not covered by tests in src/mpi/coll/op_commutative.c.gcov Uncovered lines in src/mpi/coll/red_scat_block.c.gcov 318: branch 1 taken 100% 319: -: 160: /* Get the local intracommunicator */ 320: #####: 161: if (!comm_ptr->local_comm) 321: branch 0 never executed 322: branch 1 never executed 323: #####: 162: MPIR_Setup_intercomm_localcomm(comm_ptr); 324: call 0 never executed 325: #####: 163: scatter_comm_ptr = comm_ptr->local_comm; 3 line(s) not covered by tests in src/mpi/coll/red_scat_block.c.gcov Uncovered lines in src/mpi/coll/helper_fns.c.gcov 74: 1405907: 44: fn_exit: 75: 1405907: 46: return mpi_errno; 76: #####: 48: if (request_ptr) { 77: branch 0 never executed 78: branch 1 never executed 79: #####: 49: MPID_Request_release(request_ptr); 151: 1403233: 87: fn_exit: 152: 1403233: 89: return mpi_errno; 153: #####: 91: if (request_ptr) { 154: branch 0 never executed 155: branch 1 never executed 156: #####: 92: MPID_Request_release(request_ptr); 173: -: 102: MPI_Comm comm) 174: function MPIC_Ssend called 0 returned 0% blocks executed 0% 175: #####: 103:{ 176: -: 104: int mpi_errno, context_id; 177: #####: 105: MPID_Request *request_ptr=NULL; 178: #####: 106: MPID_Comm *comm_ptr=NULL; 181: -: 109: MPIDI_PT2PT_FUNC_ENTER_FRONT(MPID_STATE_MPIC_SSEND); 182: -: 110: 183: #####: 111: MPID_Comm_get_ptr( comm, comm_ptr ); 187: branch 3 never executed 188: call 4 never executed 189: #####: 112: context_id = (comm_ptr->comm_kind == MPID_INTRACOMM) ? 190: -: 113: MPID_CONTEXT_INTRA_COLL : MPID_CONTEXT_INTER_COLL; 191: -: 114: 192: #####: 115: mpi_errno = MPID_Ssend(buf, count, datatype, dest, tag, comm_ptr, 197: branch 1 never executed 198: call 2 never executed 199: #####: 118: if (request_ptr) { 200: branch 0 never executed 201: branch 1 never executed 202: #####: 119: mpi_errno = MPIC_Wait(request_ptr); 206: branch 1 never executed 207: call 2 never executed 208: #####: 121: MPID_Request_release(request_ptr); 215: call 6 never executed 216: -: 122: } 217: #####: 123: fn_exit: 218: #####: 123: fn_exit: 219: #####: 125: return mpi_errno; 220: #####: 125: return mpi_errno; 221: #####: 127: if (request_ptr) { 222: branch 0 never executed 223: branch 1 never executed 224: #####: 128: MPID_Request_release(request_ptr); 556: -: 318: { 557: call 0 never executed 558: #####: 320: copy_sz = rdata_sz; 731: branch 1 taken 0% (fallthrough) 732: -: 414: { 733: #####: 415: memmove(buf, buf_end - buf_off, buf_off); 19 line(s) not covered by tests in src/mpi/coll/helper_fns.c.gcov All code covered by tests in src/mpi/coll/mpiimpl.h.gcov Uncovered lines in src/mpi/coll/opsum.c.gcov 141: branch 0 taken 75% 142: branch 1 taken 25% 143: #####: 38: MPIR_OP_TYPE_GROUP(FORTRAN_INTEGER_EXTRA) 152: branch 8 never executed 153: branch 9 never executed 154: #####: 39: MPIR_OP_TYPE_GROUP(FLOATING_POINT_EXTRA) 173: -: 54:#undef MPIR_OP_C_COMPLEX_TYPE_MACRO 174: -: 55:#define MPIR_OP_C_COMPLEX_TYPE_MACRO(mpi_type_,c_type_) MPIR_OP_TYPE_REDUCE_CASE(mpi_type_,c_type_,MPIR_LSUM) 175: #####: 56: MPIR_OP_TYPE_GROUP(COMPLEX) 3 line(s) not covered by tests in src/mpi/coll/opsum.c.gcov Uncovered lines in src/mpi/coll/opmin.c.gcov 107: branch 34 taken 91% 108: branch 35 taken 9% 109: #####: 32: MPIR_OP_TYPE_GROUP(FORTRAN_INTEGER) 139: branch 0 taken 75% 140: branch 1 taken 25% 141: #####: 36: MPIR_OP_TYPE_GROUP(FORTRAN_INTEGER_EXTRA) 150: branch 8 never executed 151: branch 9 never executed 152: #####: 37: MPIR_OP_TYPE_GROUP(FLOATING_POINT_EXTRA) 3 line(s) not covered by tests in src/mpi/coll/opmin.c.gcov Uncovered lines in src/mpi/coll/opbor.c.gcov 105: branch 34 taken 91% 106: branch 35 taken 9% 107: #####: 36: MPIR_OP_TYPE_GROUP(FORTRAN_INTEGER) 119: branch 0 taken 75% 120: branch 1 taken 25% 121: #####: 40: MPIR_OP_TYPE_GROUP(FORTRAN_INTEGER_EXTRA) 2 line(s) not covered by tests in src/mpi/coll/opbor.c.gcov Uncovered lines in src/mpi/coll/opland.c.gcov 208: -: 57: } 209: -: 58: /* expand logicals (which may include MPI_C_BOOL, a non-Fortran type) */ 210: #####: 59: MPIR_OP_TYPE_GROUP(LOGICAL) 240: branch 4 taken 75% 241: branch 5 taken 25% 242: #####: 73: MPIR_OP_TYPE_GROUP(FORTRAN_INTEGER) 259: branch 16 taken 91% 260: branch 17 taken 9% 261: #####: 74: MPIR_OP_TYPE_GROUP(FORTRAN_INTEGER_EXTRA) 323: branch 28 taken 75% 324: branch 29 taken 25% 325: #####: 78: MPIR_OP_TYPE_GROUP(FLOATING_POINT_EXTRA) 4 line(s) not covered by tests in src/mpi/coll/opland.c.gcov Uncovered lines in src/mpi/coll/oplxor.c.gcov 280: -: 57: } 281: -: 58: /* expand logicals (which may include MPI_C_BOOL, a non-Fortran type) */ 282: #####: 59: MPIR_OP_TYPE_GROUP(LOGICAL) 324: branch 8 taken 75% 325: branch 9 taken 25% 326: #####: 73: MPIR_OP_TYPE_GROUP(FORTRAN_INTEGER) 355: branch 28 taken 91% 356: branch 29 taken 9% 357: #####: 74: MPIR_OP_TYPE_GROUP(FORTRAN_INTEGER_EXTRA) 459: branch 48 taken 75% 460: branch 49 taken 25% 461: #####: 78: MPIR_OP_TYPE_GROUP(FLOATING_POINT_EXTRA) 4 line(s) not covered by tests in src/mpi/coll/oplxor.c.gcov Uncovered lines in src/mpi/coll/opminloc.c.gcov 153: -: 101:#ifdef HAVE_FORTRAN_BINDING 154: -: 102:#ifndef HAVE_NO_FORTRAN_MPI_TYPES_IN_C 155: #####: 103: case MPI_2INTEGER: MPIR_MINLOC_F_CASE(int); 160: branch 4 never executed 161: branch 5 never executed 162: #####: 104: case MPI_2REAL: MPIR_MINLOC_F_CASE(float); 169: branch 6 never executed 170: branch 7 never executed 171: #####: 105: case MPI_2DOUBLE_PRECISION: MPIR_MINLOC_F_CASE(double); 3 line(s) not covered by tests in src/mpi/coll/opminloc.c.gcov Uncovered lines in src/mpi/coll/opmax.c.gcov 108: branch 34 taken 91% 109: branch 35 taken 9% 110: #####: 33: MPIR_OP_TYPE_GROUP(FORTRAN_INTEGER) 140: branch 0 taken 75% 141: branch 1 taken 25% 142: #####: 37: MPIR_OP_TYPE_GROUP(FORTRAN_INTEGER_EXTRA) 151: branch 8 never executed 152: branch 9 never executed 153: #####: 38: MPIR_OP_TYPE_GROUP(FLOATING_POINT_EXTRA) 3 line(s) not covered by tests in src/mpi/coll/opmax.c.gcov Uncovered lines in src/mpi/coll/opband.c.gcov 105: branch 34 taken 91% 106: branch 35 taken 9% 107: #####: 36: MPIR_OP_TYPE_GROUP(FORTRAN_INTEGER) 119: branch 0 taken 75% 120: branch 1 taken 25% 121: #####: 40: MPIR_OP_TYPE_GROUP(FORTRAN_INTEGER_EXTRA) 2 line(s) not covered by tests in src/mpi/coll/opband.c.gcov Uncovered lines in src/mpi/coll/opbxor.c.gcov 105: branch 34 taken 91% 106: branch 35 taken 9% 107: #####: 36: MPIR_OP_TYPE_GROUP(FORTRAN_INTEGER) 119: branch 0 taken 75% 120: branch 1 taken 25% 121: #####: 40: MPIR_OP_TYPE_GROUP(FORTRAN_INTEGER_EXTRA) 2 line(s) not covered by tests in src/mpi/coll/opbxor.c.gcov Uncovered lines in src/mpi/coll/oplor.c.gcov 208: -: 57: } 209: -: 58: /* expand logicals (which may include MPI_C_BOOL, a non-Fortran type) */ 210: #####: 59: MPIR_OP_TYPE_GROUP(LOGICAL) 240: branch 4 taken 75% 241: branch 5 taken 25% 242: #####: 73: MPIR_OP_TYPE_GROUP(FORTRAN_INTEGER) 259: branch 16 taken 91% 260: branch 17 taken 9% 261: #####: 74: MPIR_OP_TYPE_GROUP(FORTRAN_INTEGER_EXTRA) 323: branch 28 taken 75% 324: branch 29 taken 25% 325: #####: 78: MPIR_OP_TYPE_GROUP(FLOATING_POINT_EXTRA) 4 line(s) not covered by tests in src/mpi/coll/oplor.c.gcov Uncovered lines in src/mpi/coll/opprod.c.gcov 119: branch 34 taken 91% 120: branch 35 taken 9% 121: #####: 34: MPIR_OP_TYPE_GROUP(FORTRAN_INTEGER) 141: branch 0 taken 75% 142: branch 1 taken 25% 143: #####: 38: MPIR_OP_TYPE_GROUP(FORTRAN_INTEGER_EXTRA) 152: branch 8 never executed 153: branch 9 never executed 154: #####: 39: MPIR_OP_TYPE_GROUP(FLOATING_POINT_EXTRA) 174: -: 55:#undef MPIR_OP_C_COMPLEX_TYPE_MACRO 175: -: 56:#define MPIR_OP_C_COMPLEX_TYPE_MACRO(mpi_type_,c_type_) MPIR_OP_TYPE_REDUCE_CASE(mpi_type_,c_type_,MPIR_LPROD) 176: #####: 57: MPIR_OP_TYPE_GROUP(COMPLEX) 4 line(s) not covered by tests in src/mpi/coll/opprod.c.gcov Uncovered lines in src/mpi/coll/opmaxloc.c.gcov 154: -: 102:#ifdef HAVE_FORTRAN_BINDING 155: -: 103:#ifndef HAVE_NO_FORTRAN_MPI_TYPES_IN_C 156: #####: 104: case MPI_2INTEGER: MPIR_MAXLOC_F_CASE(int); 161: branch 4 never executed 162: branch 5 never executed 163: #####: 105: case MPI_2REAL: MPIR_MAXLOC_F_CASE(float); 170: branch 6 never executed 171: branch 7 never executed 172: #####: 106: case MPI_2DOUBLE_PRECISION: MPIR_MAXLOC_F_CASE(double); 3 line(s) not covered by tests in src/mpi/coll/opmaxloc.c.gcov Uncovered lines in src/mpi/comm/comm_create.c.gcov 411: branch 0 taken 0% (fallthrough) 412: branch 1 taken 100% 413: #####: 307: MPIR_Comm_release(newcomm_ptr, 0/*isDisconnect*/); 414: call 0 never executed 415: #####: 308: new_context_id = 0; /* MPIR_Comm_release frees the new ctx id */ 2 line(s) not covered by tests in src/mpi/comm/comm_create.c.gcov All code covered by tests in src/mpi/comm/comm_dup.c.gcov All code covered by tests in src/mpi/comm/comm_get_name.c.gcov All code covered by tests in src/mpi/comm/comm_rank.c.gcov All code covered by tests in src/mpi/comm/comm_size.c.gcov All code covered by tests in src/mpi/comm/comm_remote_size.c.gcov All code covered by tests in src/mpi/comm/comm_set_name.c.gcov All code covered by tests in src/mpi/comm/comm_test_inter.c.gcov All code covered by tests in src/mpi/comm/intercomm_merge.c.gcov Uncovered lines in src/mpi/comm/commutil.c.gcov 277: branch 0 taken 0% (fallthrough) 278: branch 1 taken 100% 279: #####: 239: MPIU_Free(comm->intranode_table); 282: branch 0 taken 0% (fallthrough) 283: branch 1 taken 100% 284: #####: 241: MPIU_Free(comm->internode_table); 451: branch 0 taken 0% (fallthrough) 452: branch 1 taken 100% 453: #####: 351: curr_nodeidx++; 455: branch 0 taken 0% (fallthrough) 456: branch 1 taken 100% 457: #####: 353: return 0; 593: -: 471: } 594: -: 472: } 595: #####: 473: return 0; 5 line(s) not covered by tests in src/mpi/comm/commutil.c.gcov All code covered by tests in src/mpi/comm/comm_compare.c.gcov All code covered by tests in src/mpi/comm/comm_free.c.gcov All code covered by tests in src/mpi/comm/comm_group.c.gcov All code covered by tests in src/mpi/comm/comm_remote_group.c.gcov All code covered by tests in src/mpi/comm/comm_split.c.gcov Uncovered lines in src/mpi/comm/intercomm_create.c.gcov 556: branch 0 taken 0% (fallthrough) 557: branch 1 taken 100% 558: #####: 388: MPIR_Nest_decr(); 573: branch 0 taken 0% (fallthrough) 574: branch 1 taken 100% 575: #####: 401: MPIR_Nest_decr(); 583: branch 0 taken 0% (fallthrough) 584: branch 1 taken 100% 585: #####: 408: MPIR_Nest_decr(); 3 line(s) not covered by tests in src/mpi/comm/intercomm_create.c.gcov All code covered by tests in src/mpi/comm/mpiimpl.h.gcov All code covered by tests in src/mpi/datatype/unpack.c.gcov All code covered by tests in src/mpi/datatype/address.c.gcov All code covered by tests in src/mpi/datatype/get_address.c.gcov All code covered by tests in src/mpi/datatype/get_count.c.gcov Uncovered lines in src/mpi/datatype/get_elements.c.gcov 108: -: 88:#ifdef HAVE_FORTRAN_BINDING 109: -: 89: case MPI_2REAL: 110: #####: 90: type1_sz = type2_sz = MPID_Datatype_get_basic_size(MPI_REAL); 111: #####: 91: break; 112: -: 92: case MPI_2DOUBLE_PRECISION: 113: #####: 93: type1_sz = type2_sz = 114: -: 94: MPID_Datatype_get_basic_size(MPI_DOUBLE_PRECISION); 115: #####: 95: break; 116: -: 96: case MPI_2INTEGER: 117: #####: 97: type1_sz = type2_sz = MPID_Datatype_get_basic_size(MPI_INTEGER); 118: #####: 98: break; 119: -: 99:#endif 120: -: 100: case MPI_2INT: 121: #####: 101: type1_sz = type2_sz = MPID_Datatype_get_basic_size(MPI_INT); 122: #####: 102: break; 123: -: 103: case MPI_FLOAT_INT: 124: #####: 104: type1_sz = MPID_Datatype_get_basic_size(MPI_FLOAT); 125: #####: 105: type2_sz = MPID_Datatype_get_basic_size(MPI_INT); 126: #####: 106: break; 130: 1: 110: break; 131: -: 111: case MPI_LONG_INT: 132: #####: 112: type1_sz = MPID_Datatype_get_basic_size(MPI_LONG); 133: #####: 113: type2_sz = MPID_Datatype_get_basic_size(MPI_INT); 134: #####: 114: break; 135: -: 115: case MPI_SHORT_INT: 136: #####: 116: type1_sz = MPID_Datatype_get_basic_size(MPI_SHORT); 137: #####: 117: type2_sz = MPID_Datatype_get_basic_size(MPI_INT); 138: #####: 118: break; 139: -: 119: case MPI_LONG_DOUBLE_INT: 140: #####: 120: type1_sz = MPID_Datatype_get_basic_size(MPI_LONG_DOUBLE); 141: #####: 121: type2_sz = MPID_Datatype_get_basic_size(MPI_INT); 142: #####: 122: break; 219: branch 0 taken 0% (fallthrough) 220: branch 1 taken 100% 221: #####: 182: return MPIR_Type_get_basic_type_elements(bytes_p, 238: branch 0 taken 0% (fallthrough) 239: branch 1 taken 100% 240: #####: 198: return MPI_ERR_TYPE; 244: branch 0 taken 0% (fallthrough) 245: branch 1 taken 100% 246: #####: 202: return MPI_ERR_TYPE; 250: branch 0 taken 0% (fallthrough) 251: branch 1 taken 100% 252: #####: 206: return MPI_ERR_TYPE; 256: branch 0 taken 0% (fallthrough) 257: branch 1 taken 100% 258: #####: 210: return MPI_ERR_TYPE; 268: -: 214: case MPI_COMBINER_DUP: 269: -: 215: case MPI_COMBINER_RESIZED: 270: #####: 216: return MPIR_Type_get_elements(bytes_p, count, *types); 276: -: 221: case MPI_COMBINER_HVECTOR: 277: -: 222: /* count is first in ints array */ 278: #####: 223: return MPIR_Type_get_elements(bytes_p, count * (*ints), *types); 281: -: 225: case MPI_COMBINER_INDEXED_BLOCK: 282: -: 226: /* count is first in ints array, blocklength is second */ 283: #####: 227: return MPIR_Type_get_elements(bytes_p, 289: -: 232: case MPI_COMBINER_HINDEXED_INTEGER: 290: -: 233: case MPI_COMBINER_HINDEXED: 291: #####: 234: for (i=0; i < (*ints); i++) { 293: branch 1 never executed 294: -: 235: /* add up the blocklengths to get a max. # of the next type */ 295: #####: 236: typecount += ints[i+1]; 296: -: 237: } 297: #####: 238: return MPIR_Type_get_elements(bytes_p, count * typecount, *types); 528: branch 0 taken 0% (fallthrough) 529: branch 1 taken 100% 530: #####: 393: *elements = MPI_UNDEFINED; 32 line(s) not covered by tests in src/mpi/datatype/get_elements.c.gcov All code covered by tests in src/mpi/datatype/pack.c.gcov All code covered by tests in src/mpi/datatype/mpiimpl.h.gcov All code covered by tests in src/mpi/datatype/pack_size.c.gcov All code covered by tests in src/mpi/datatype/status_set_elements.c.gcov All code covered by tests in src/mpi/datatype/type_get_name.c.gcov All code covered by tests in src/mpi/datatype/type_set_name.c.gcov All code covered by tests in src/mpi/datatype/type_size.c.gcov All code covered by tests in src/mpi/datatype/type_extent.c.gcov All code covered by tests in src/mpi/datatype/type_vector.c.gcov All code covered by tests in src/mpi/datatype/type_commit.c.gcov All code covered by tests in src/mpi/datatype/type_indexed.c.gcov All code covered by tests in src/mpi/datatype/type_hindexed.c.gcov All code covered by tests in src/mpi/datatype/type_struct.c.gcov All code covered by tests in src/mpi/datatype/type_contiguous.c.gcov All code covered by tests in src/mpi/datatype/type_free.c.gcov All code covered by tests in src/mpi/datatype/type_hvector.c.gcov All code covered by tests in src/mpi/datatype/type_dup.c.gcov All code covered by tests in src/mpi/datatype/type_get_envelope.c.gcov All code covered by tests in src/mpi/datatype/type_get_contents.c.gcov All code covered by tests in src/mpi/datatype/type_ub.c.gcov All code covered by tests in src/mpi/datatype/type_lb.c.gcov All code covered by tests in src/mpi/datatype/type_get_extent.c.gcov All code covered by tests in src/mpi/datatype/type_get_true_extent.c.gcov All code covered by tests in src/mpi/datatype/type_match_size.c.gcov All code covered by tests in src/mpi/datatype/type_create_struct.c.gcov All code covered by tests in src/mpi/datatype/type_create_hindexed.c.gcov All code covered by tests in src/mpi/datatype/type_create_hvector.c.gcov Uncovered lines in src/mpi/datatype/pack_external.c.gcov 161: branch 0 taken 0% (fallthrough) 162: branch 1 taken 100% 163: #####: 109: goto fn_exit; 1 line(s) not covered by tests in src/mpi/datatype/pack_external.c.gcov All code covered by tests in src/mpi/datatype/pack_external_size.c.gcov Uncovered lines in src/mpi/datatype/unpack_external.c.gcov 156: branch 0 taken 0% (fallthrough) 157: branch 1 taken 100% 158: #####: 107: goto fn_exit; 1 line(s) not covered by tests in src/mpi/datatype/unpack_external.c.gcov All code covered by tests in src/mpi/datatype/type_create_indexed_block.c.gcov All code covered by tests in src/mpi/datatype/type_create_resized.c.gcov Uncovered lines in src/mpi/datatype/type_create_darray.c.gcov 84: 924: 76: blksize = (global_size + nprocs - 1)/nprocs; 85: -: 77: else { 86: #####: 78: blksize = darg; 129: branch 0 taken 0% (fallthrough) 130: branch 1 taken 100% 131: #####: 113: if (dim == 0) { 132: branch 0 never executed 133: branch 1 never executed 134: #####: 114: mpi_errno = MPID_Type_contiguous(mysize, 148: -: 124: } 149: -: 125: else { 150: #####: 126: for (i=0; idim; i--) stride *= (MPI_Aint)(array_of_gsizes[i]); 295: branch 1 never executed 296: -: 238: 297: #####: 239: mpi_errno = MPID_Type_vector(count, 313: -: 244: type_new); 314: -: 252: 315: #####: 253: if (rem) { 319: -: 255: it separately using MPI_Type_struct */ 320: -: 256: 321: #####: 257: types[0] = *type_new; 322: #####: 258: types[1] = type_old; 323: #####: 259: disps[0] = 0; 324: #####: 260: disps[1] = (MPI_Aint) count * stride; 325: #####: 261: blklens[0] = 1; 326: #####: 262: blklens[1] = rem; 327: -: 263: 328: #####: 264: mpi_errno = MPID_Type_struct(2, 332: -: 267: types, 333: -: 268: &type_tmp); 334: #####: 269: MPIR_Nest_incr(); 335: #####: 270: NMPI_Type_free(type_new); 336: call 0 never executed 337: #####: 271: MPIR_Nest_decr(); 338: #####: 272: *type_new = type_tmp; 352: -: 283: /* In the first iteration, we need to set the displacement in that 353: -: 284: dimension correctly. */ 354: #####: 285: if (((order == MPI_ORDER_FORTRAN) && (dim == 0)) || 361: -: 286: ((order == MPI_ORDER_C) && (dim == ndims-1))) 362: -: 287: { 363: #####: 288: types[0] = MPI_LB; 364: #####: 289: disps[0] = 0; 365: #####: 290: types[1] = *type_new; 366: #####: 291: disps[1] = (MPI_Aint) rank * (MPI_Aint) blksize * orig_extent; 367: #####: 292: types[2] = MPI_UB; 368: #####: 293: disps[2] = orig_extent * (MPI_Aint)(array_of_gsizes[dim]); 369: #####: 294: blklens[0] = blklens[1] = blklens[2] = 1; 370: #####: 295: mpi_errno = MPID_Type_struct(3, 374: -: 298: types, 375: -: 299: &type_tmp); 376: #####: 300: MPIR_Nest_incr(); 377: #####: 301: NMPI_Type_free(type_new); 378: call 0 never executed 379: #####: 302: MPIR_Nest_decr(); 380: #####: 303: *type_new = type_tmp; 391: -: 304: 392: -: 312: 393: #####: 313: *st_offset = 0; /* set it to 0 because it is taken care of in 395: -: 315: } 396: -: 316: else { 397: #####: 317: *st_offset = (MPI_Aint) rank * (MPI_Aint) blksize; 400: -: 320: } 401: -: 321: 402: #####: 322: if (local_size == 0) *st_offset = 0; 404: branch 1 never executed 405: -: 323: 406: #####: 324: return MPI_SUCCESS; 714: branch 1 taken 100% 715: -: 529: /* dimension 0 changes fastest */ 716: #####: 530: for (i=0; ierrhandler->handle == MPI_ERRORS_ARE_FATAL) { 156: call 0 returned 0% 157: #####: 106: goto fn_exit; 162: branch 1 taken 100% 163: -: 110: /* MPI_ERRORS_RETURN should always return MPI_SUCCESS */ 164: #####: 111: goto fn_exit; 173: branch 0 taken 0% (fallthrough) 174: branch 1 taken 100% 175: #####: 120: mpi_errno = errorcode; 176: #####: 121: goto fn_exit; 198: -: 139: case MPID_LANG_FORTRAN90: 199: -: 140: case MPID_LANG_FORTRAN: 200: #####: 141: (*comm_ptr->errhandler->errfn.F77_Handler_function)( 5 line(s) not covered by tests in src/mpi/errhan/comm_call_errhandler.c.gcov All code covered by tests in src/mpi/errhan/comm_create_errhandler.c.gcov Uncovered lines in src/mpi/errhan/comm_get_errhandler.c.gcov 133: branch 0 taken 0% (fallthrough) 134: branch 1 taken 100% 135: #####: 96: *errhandler = MPI_ERRORS_ARE_FATAL; 1 line(s) not covered by tests in src/mpi/errhan/comm_get_errhandler.c.gcov All code covered by tests in src/mpi/errhan/comm_set_errhandler.c.gcov All code covered by tests in src/mpi/errhan/errhandler_create.c.gcov All code covered by tests in src/mpi/errhan/errhandler_free.c.gcov All code covered by tests in src/mpi/errhan/errhandler_get.c.gcov All code covered by tests in src/mpi/errhan/errhandler_set.c.gcov All code covered by tests in src/mpi/errhan/error_class.c.gcov All code covered by tests in src/mpi/errhan/error_string.c.gcov All code covered by tests in src/mpi/errhan/file_create_errhandler.c.gcov All code covered by tests in src/mpi/errhan/file_get_errhandler.c.gcov Uncovered lines in src/mpi/errhan/file_set_errhandler.c.gcov 241: branch 0 taken 0% (fallthrough) 242: branch 1 taken 100% 243: #####: 176: *c = 0; 244: #####: 177: *kind = 1; /* Use errors return as the default */ 258: branch 1 taken 100% 259: -: 182: /* FIXME: We need an error return */ 260: #####: 183: *c = 0; 261: #####: 184: *kind = 1; 262: #####: 185: return; 272: branch 1 taken 100% 273: -: 189: /* FIXME: We need an error return */ 274: #####: 190: *c = 0; 275: #####: 191: *kind = 1; 276: #####: 192: return; 279: branch 0 taken 0% (fallthrough) 280: branch 1 taken 100% 281: #####: 195: *c = 0; 282: #####: 196: *kind = 1; 285: branch 0 taken 0% (fallthrough) 286: branch 1 taken 100% 287: #####: 199: *c = 0; 288: #####: 200: *kind = 0; 12 line(s) not covered by tests in src/mpi/errhan/file_set_errhandler.c.gcov Uncovered lines in src/mpi/errhan/file_call_errhandler.c.gcov 91: branch 0 taken 0% (fallthrough) 92: branch 1 taken 100% 93: #####: 81: mpi_errno = errorcode; 94: #####: 82: goto fn_exit; 98: branch 0 taken 0% (fallthrough) 99: branch 1 taken 100% 100: #####: 86: MPID_Errhandler_get_ptr( MPI_ERRORS_RETURN, e ); 142: -: 117: the value is really const (but MPI didn't define error handlers 143: -: 118: with const), this preserves the intent */ 144: #####: 119: { void *fh1 = (void *)&fh; 145: #####: 120: (*e->errfn.F77_Handler_function)( fh1, &errorcode ); 5 line(s) not covered by tests in src/mpi/errhan/file_call_errhandler.c.gcov All code covered by tests in src/mpi/errhan/win_create_errhandler.c.gcov Uncovered lines in src/mpi/errhan/win_call_errhandler.c.gcov 131: -: 98: win_ptr->errhandler->handle == MPI_ERRORS_ARE_FATAL) { 132: call 0 never executed 133: #####: 100: goto fn_exit; 138: branch 1 taken 100% 139: -: 104: /* MPI_ERRORS_RETURN should always return MPI_SUCCESS */ 140: #####: 105: goto fn_exit; 149: branch 0 taken 0% (fallthrough) 150: branch 1 taken 100% 151: #####: 114: mpi_errno = errorcode; 152: #####: 115: goto fn_exit; 172: -: 131: case MPID_LANG_FORTRAN90: 173: -: 132: case MPID_LANG_FORTRAN: 174: #####: 133: (*win_ptr->errhandler->errfn.F77_Handler_function)( 5 line(s) not covered by tests in src/mpi/errhan/win_call_errhandler.c.gcov All code covered by tests in src/mpi/errhan/win_get_errhandler.c.gcov All code covered by tests in src/mpi/errhan/win_set_errhandler.c.gcov Uncovered lines in src/mpi/errhan/errutil.c.gcov 234: branch 0 taken 0% (fallthrough) 235: branch 1 taken 100% 236: #####: 218: MPIU_Error_printf("Attempting to use an MPI routine before initializing MPICH\n"); 244: -: 222: } 245: -: 223: else { 246: #####: 224: MPIU_Error_printf("Internal Error: Unknown state of MPI (neither initialized nor finalized)\n" ); 360: -: 306: case MPID_LANG_FORTRAN90: 361: -: 307: case MPID_LANG_FORTRAN: 362: #####: 308: (*comm_ptr->errhandler->errfn.F77_Handler_function)( 415: -: 342: win_ptr->errhandler->handle == MPI_ERRORS_ARE_FATAL) { 416: -: 343: /* Calls MPID_Abort */ 417: #####: 344: handleFatalError( NULL, fcname, errcode ); 428: -: 351: win_ptr->errhandler->handle == MPIR_ERRORS_THROW_EXCEPTIONS) 429: -: 352: { 430: #####: 353: return errcode; 453: -: 371:#ifdef HAVE_CXX_BINDING 454: -: 372: case MPID_LANG_CXX: 455: #####: 373: (*MPIR_Process.cxx_call_errfn)( 2, &win_ptr->handle, &errcode, 459: -: 376: returns something other than MPI_SUCCESS. There is no "return" 460: -: 377: of an error code. */ 461: #####: 378: errcode = MPI_SUCCESS; 462: #####: 379: break; 465: -: 382: case MPID_LANG_FORTRAN90: 466: -: 383: case MPID_LANG_FORTRAN: 467: #####: 384: (*win_ptr->errhandler->errfn.F77_Handler_function)( 518: branch 1 taken 100% 519: -: 430: { 520: #####: 431: if (errcode & ~ERROR_CLASS_MASK) 522: branch 1 never executed 523: -: 432: { 524: #####: 433: MPIU_Error_printf("INTERNAL ERROR: Invalid error class (%d) encountered while returning from\n" 533: -: 441: else 534: -: 442: { 535: #####: 443: MPIU_Error_printf("INTERNAL ERROR: Invalid error class (%d) encountered while returning from\n" 539: -: 446: /* FIXME: We probably want to set this to MPI_ERR_UNKNOWN 540: -: 447: and discard the rest of the bits */ 541: #####: 448: errcode = (errcode & ~ERROR_CLASS_MASK) | MPI_ERR_UNKNOWN; 542: #####: 449: rc = 1; 638: -: 528: { 639: -: 529: /* don't return here if the string partially matches */ 640: #####: 530: if (strncmp(generic_err_msgs[i].short_name, msg, strlen(msg)) != 0) 643: branch 2 never executed 644: branch 3 never executed 645: #####: 531: return -1; 646: -: 532: } 647: -: 533: } 648: #####: 534: return -1; 698: -: 572: { 699: -: 573: /* don't return here if the string partially matches */ 700: #####: 574: if (strncmp(specific_err_msgs[i].short_name, msg, strlen(msg)) != 0) 703: branch 2 never executed 704: branch 3 never executed 705: #####: 575: return -1; 706: -: 576: } 707: -: 577: } 708: #####: 578: return -1; 782: -: 645: } 783: -: 646: else { 784: #####: 647: return "Unknown error class"; 805: branch 0 taken 0% (fallthrough) 806: branch 1 taken 100% 807: #####: 667: num_remaining = MPI_MAX_ERROR_STRING; 848: -: 697: num_remaining)) 849: -: 698: { 850: #####: 699: msg[num_remaining - 1] = '\0'; 861: branch 1 taken 100% 862: -: 707: { 863: #####: 708: fn(errorcode, msg, length); 872: branch 3 taken 100% 873: -: 713: { 874: #####: 714: msg[num_remaining - 1] = '\0'; 885: branch 1 taken 100% 886: -: 724: { 887: #####: 725: fn(errorcode, msg, num_remaining); 943: -: 776:static const char * GetAssertString(int d) 944: function GetAssertString called 0 returned 0% blocks executed 0% 945: #####: 777:{ 946: -: 778: static char str[ASSERT_STR_MAXLEN] = ""; 947: -: 779: char *cur; 948: #####: 780: size_t len = ASSERT_STR_MAXLEN; 949: -: 781: size_t n; 950: -: 782: 951: #####: 783: if (d == 0) 953: branch 1 never executed 954: -: 784: { 955: #####: 785: MPIU_Strncpy(str, "assert=0", ASSERT_STR_MAXLEN); 956: call 0 never executed 957: #####: 786: return str; 958: -: 787: } 959: #####: 788: cur = str; 960: #####: 789: if (d & MPI_MODE_NOSTORE) 962: branch 1 never executed 963: -: 790: { 964: #####: 791: MPIU_Strncpy(cur, "MPI_MODE_NOSTORE", len); 965: call 0 never executed 966: #####: 792: n = strlen(cur); 967: call 0 never executed 968: #####: 793: cur += n; 969: #####: 794: len -= n; 970: #####: 795: d ^= MPI_MODE_NOSTORE; 971: -: 796: } 972: #####: 797: if (d & MPI_MODE_NOCHECK) 974: branch 1 never executed 975: -: 798: { 976: #####: 799: if (len < ASSERT_STR_MAXLEN) 977: branch 0 never executed 978: branch 1 never executed 979: #####: 800: MPIU_Strncpy(cur, " | MPI_MODE_NOCHECK", len); 980: call 0 never executed 981: -: 801: else 982: #####: 802: MPIU_Strncpy(cur, "MPI_MODE_NOCHECK", len); 983: call 0 never executed 984: #####: 803: n = strlen(cur); 985: call 0 never executed 986: #####: 804: cur += n; 987: #####: 805: len -= n; 988: #####: 806: d ^= MPI_MODE_NOCHECK; 989: -: 807: } 990: #####: 808: if (d & MPI_MODE_NOPUT) 992: branch 1 never executed 993: -: 809: { 994: #####: 810: if (len < ASSERT_STR_MAXLEN) 995: branch 0 never executed 996: branch 1 never executed 997: #####: 811: MPIU_Strncpy(cur, " | MPI_MODE_NOPUT", len); 998: call 0 never executed 999: -: 812: else 1000: #####: 813: MPIU_Strncpy(cur, "MPI_MODE_NOPUT", len); 1001: call 0 never executed 1002: #####: 814: n = strlen(cur); 1003: call 0 never executed 1004: #####: 815: cur += n; 1005: #####: 816: len -= n; 1006: #####: 817: d ^= MPI_MODE_NOPUT; 1007: -: 818: } 1008: #####: 819: if (d & MPI_MODE_NOPRECEDE) 1010: branch 1 never executed 1011: -: 820: { 1012: #####: 821: if (len < ASSERT_STR_MAXLEN) 1013: branch 0 never executed 1014: branch 1 never executed 1015: #####: 822: MPIU_Strncpy(cur, " | MPI_MODE_NOPRECEDE", len); 1016: call 0 never executed 1017: -: 823: else 1018: #####: 824: MPIU_Strncpy(cur, "MPI_MODE_NOPRECEDE", len); 1019: call 0 never executed 1020: #####: 825: n = strlen(cur); 1021: call 0 never executed 1022: #####: 826: cur += n; 1023: #####: 827: len -= n; 1024: #####: 828: d ^= MPI_MODE_NOPRECEDE; 1025: -: 829: } 1026: #####: 830: if (d & MPI_MODE_NOSUCCEED) 1028: branch 1 never executed 1029: -: 831: { 1030: #####: 832: if (len < ASSERT_STR_MAXLEN) 1031: branch 0 never executed 1032: branch 1 never executed 1033: #####: 833: MPIU_Strncpy(cur, " | MPI_MODE_NOSUCCEED", len); 1034: call 0 never executed 1035: -: 834: else 1036: #####: 835: MPIU_Strncpy(cur, "MPI_MODE_NOSUCCEED", len); 1037: call 0 never executed 1038: #####: 836: n = strlen(cur); 1039: call 0 never executed 1040: #####: 837: cur += n; 1041: #####: 838: len -= n; 1042: #####: 839: d ^= MPI_MODE_NOSUCCEED; 1043: -: 840: } 1044: #####: 841: if (d) 1046: branch 1 never executed 1047: -: 842: { 1048: #####: 843: if (len < ASSERT_STR_MAXLEN) 1049: branch 0 never executed 1050: branch 1 never executed 1051: #####: 844: MPIU_Snprintf(cur, len, " | 0x%x", d); 1052: call 0 never executed 1053: -: 845: else 1054: #####: 846: MPIU_Snprintf(cur, len, "assert=0x%x", d); 1055: call 0 never executed 1056: -: 847: } 1057: #####: 848: return str; 1072: -: 858: (HANDLE_GET_KIND(d) == HANDLE_KIND_INVALID && \ 1073: -: 859: d != MPI_DATATYPE_NULL)) 1074: #####: 860: return "INVALID DATATYPE"; 1084: branch 1 taken 100% 1085: -: 867: { 1086: #####: 868: MPIU_Strncpy(default_str, "dtype=0x0", 64); 1087: call 0 never executed 1088: #####: 869: return default_str; 1102: branch 1 taken 100% 1103: -: 878: { 1104: #####: 879: MPIU_Snprintf(default_str, 64, "dtype=0x%08x", d); 1105: call 0 never executed 1106: #####: 880: return default_str; 1116: branch 1 taken 100% 1117: -: 888: { 1118: #####: 889: MPIU_Snprintf(default_str, 64, "dtype=USER<0x%08x>", d); 1119: call 0 never executed 1120: #####: 890: return default_str; 1174: 14: 927: return "MPI_MAXLOC"; 1175: -: 928: case MPI_REPLACE: 1176: #####: 929: return "MPI_REPLACE"; 1177: -: 930: } 1178: -: 931: /* FIXME: default is not thread safe */ 1179: #####: 932: MPIU_Snprintf(default_str, 64, "op=0x%x", o); 1180: call 0 never executed 1181: #####: 933: return default_str; 1218: branch 1 taken 100% 1219: -: 967: { 1220: #####: 968: if (maxlen > 0 && str != NULL) 1221: branch 0 never executed 1222: branch 1 never executed 1223: #####: 969: *str = '\0'; 1224: #####: 970: return 0; 1302: call 0 returned 100% 1303: -: 995: else { 1304: #####: 996: MPIU_Strncpy(str, "", maxlen ); 1312: 1244: 1002: break; 1313: -: 1003: case (int)'L': 1314: #####: 1004: ll = va_arg(list, long long); 1315: #####: 1005: MPIU_Snprintf(str, maxlen, "%lld", ll); 1316: call 0 never executed 1317: #####: 1006: break; 1318: -: 1007: case (int)'x': 1319: #####: 1008: d = va_arg(list, int); 1320: #####: 1009: MPIU_Snprintf(str, maxlen, "%x", d); 1321: call 0 never executed 1322: #####: 1010: break; 1323: -: 1011: case (int)'X': 1324: #####: 1012: ll = va_arg(list, long long); 1325: #####: 1013: MPIU_Snprintf(str, maxlen, "%llx", ll); 1326: call 0 never executed 1327: #####: 1014: break; 1339: 8: 1021: break; 1340: -: 1022: case MPI_PROC_NULL: 1341: #####: 1023: MPIU_Strncpy(str, "MPI_PROC_NULL", maxlen); 1342: call 0 never executed 1343: #####: 1024: break; 1364: 21: 1039: break; 1365: -: 1040: case MPI_UNDEFINED: 1366: #####: 1041: MPIU_Strncpy(str, "MPI_UNDEFINED", maxlen); 1367: call 0 never executed 1368: #####: 1042: break; 1381: branch 1 taken 100% 1382: -: 1053: { 1383: #####: 1054: MPIU_Strncpy(str, "MPI_IN_PLACE", maxlen); 1431: -: 1089: else 1432: -: 1090: { 1433: #####: 1091: MPIU_Snprintf(str, maxlen, "info=0x%x", I); 1446: -: 1101: { 1447: -: 1102: MPI_File F; 1448: #####: 1103: F = va_arg(list, MPI_File); 1449: #####: 1104: if (F == MPI_FILE_NULL) 1451: branch 1 never executed 1452: -: 1105: { 1453: #####: 1106: MPIU_Strncpy(str, "MPI_FILE_NULL", maxlen); 1456: -: 1108: else 1457: -: 1109: { 1458: #####: 1110: MPIU_Snprintf(str, maxlen, "file=0x%lx", (unsigned long)F); 1468: branch 1 taken 100% 1469: -: 1118: { 1470: #####: 1119: MPIU_Strncpy(str, "MPI_WIN_NULL", maxlen); 1478: -: 1125: break; 1479: -: 1126: case (int)'A': 1480: #####: 1127: d = va_arg(list, int); 1481: #####: 1128: MPIU_Snprintf(str, maxlen, "%s", GetAssertString(d)); 1482: call 0 never executed 1483: call 1 never executed 1484: #####: 1129: break; 1505: 325: 1144: break; 1506: -: 1145: case (int)'R': 1507: #####: 1146: R = va_arg(list, MPI_Request); 1508: #####: 1147: if (R == MPI_REQUEST_NULL) 1510: branch 1 never executed 1511: -: 1148: { 1512: #####: 1149: MPIU_Strncpy(str, "MPI_REQUEST_NULL", maxlen); 1515: -: 1151: else 1516: -: 1152: { 1517: #####: 1153: MPIU_Snprintf(str, maxlen, "req=0x%x", R); 1536: -: 1167: default: 1537: -: 1168: /* Error: unhandled output type */ 1538: #####: 1169: return 0; 1745: branch 2 taken 0% (fallthrough) 1746: branch 3 taken 100% 1747: #####: 1364: *ring_idx > max_error_ring_loc) return 1; 1766: branch 2 taken 0% (fallthrough) 1767: branch 3 taken 100% 1768: #####: 1377: ring_idx > max_error_ring_loc) return 1; 1779: -: 1384:static const char *ErrcodeInvalidReasonStr( int reason ) 1780: function ErrcodeInvalidReasonStr called 0 returned 0% blocks executed 0% 1781: #####: 1385:{ 1782: #####: 1386: const char *str = 0; 1783: #####: 1387: switch (reason) { 1787: branch 3 never executed 1788: -: 1388: case 1: 1789: #####: 1389: str = "Ring Index out of range"; 1790: #####: 1390: break; 1791: -: 1391: case 2: 1792: #####: 1392: str = "Ring ids do not match"; 1793: #####: 1393: break; 1794: -: 1394: case 3: 1795: #####: 1395: str = "Generic message index out of range"; 1796: #####: 1396: break; 1797: -: 1397: default: 1798: #####: 1398: str = "Unknown reason for invalid errcode"; 1799: -: 1399: break; 1800: -: 1400: } 1801: #####: 1401: return str; 1821: branch 2 taken 100% 1822: -: 1416: &generic_idx ) != 0) { 1823: #####: 1417: MPIU_Error_printf( 1876: branch 0 taken 0% (fallthrough) 1877: branch 1 taken 100% 1878: #####: 1459: MPIU_Error_printf( "Internal Error: invalid error code %x (%s) in %s:%d\n", 1881: -: 1460: lastcode, ErrcodeInvalidReasonStr( reason ), 1882: -: 1461: fcname, line ); 1883: #####: 1462: lastcode = MPI_SUCCESS; 1964: -: 1518: } 1965: -: 1519: else { 1966: #####: 1520: specific_fmt = specific_msg; 1974: -: 1527: } 1975: -: 1528: else { 1976: #####: 1529: user_ring_msg[0] = 0; 1982: -: 1535: { 1983: -: 1536: /* TODO: lookup index for class error message */ 1984: #####: 1537: err_code &= ~ERROR_GENERIC_MASK; 2014: branch 0 taken 0% (fallthrough) 2015: branch 1 taken 100% 2016: #####: 1567: error_ring_loc %= MAX_ERROR_RING; 2036: -: 1580: else 2037: -: 1581: { 2038: #####: 1582: specific_fmt = specific_msg; 2061: -: 1598: else 2062: -: 1599: { 2063: #####: 1600: MPIU_Strncpy( ring_msg, generic_msg, MPIR_MAX_ERROR_LINE ); 2096: -: 1624: &last_ring_id, 2097: -: 1625: &last_generic_idx ) != 0) { 2098: #####: 1626: MPIU_Error_printf( 2129: -: 1647: else 2130: -: 1648: { 2131: #####: 1649: ErrorRing[ring_idx].location[0] = '\0'; 2147: branch 4 taken 100% 2148: -: 1661: { 2149: #####: 1662: err_code |= ERROR_FATAL_MASK; 2161: -: 1674:int MPIR_Err_combine_codes(int error1, int error2) 2162: function MPIR_Err_combine_codes called 0 returned 0% blocks executed 0% 2163: #####: 1675:{ 2164: #####: 1676: int error1_code = error1; 2165: #####: 1677: int error2_code = error2; 2166: -: 1678: int error2_class; 2167: -: 1679: 2168: #####: 1680: if (error2_code == MPI_SUCCESS) return error1_code; 2169: branch 0 never executed 2170: branch 1 never executed 2171: #####: 1681: if (error2_code & ERROR_DYN_MASK) return error2_code; 2172: branch 0 never executed 2173: branch 1 never executed 2174: #####: 1682: if (error1_code == MPI_SUCCESS) return error2_code; 2176: branch 1 never executed 2177: -: 1683: 2178: #####: 1684: error2_class = MPIR_ERR_GET_CLASS(error2_code); 2179: #####: 1685: if (MPIR_ERR_GET_CLASS(error2_class) < MPI_SUCCESS || 2182: -: 1686: MPIR_ERR_GET_CLASS(error2_class) > MPICH_ERR_LAST_CLASS) 2183: -: 1687: { 2184: #####: 1688: error2_class = MPI_ERR_OTHER; 2189: -: 1693: int error_code; 2190: -: 1694: 2191: #####: 1695: error_code = error1_code; 2200: -: 1704: int generic_idx; 2201: -: 1705: 2202: #####: 1706: if (convertErrcodeToIndexes(error_code, &ring_idx, &ring_id, 2214: -: 1711: } 2215: -: 1712: 2216: #####: 1713: error_code = ErrorRing[ring_idx].prev_error; 2217: -: 1714: 2218: #####: 1715: if (error_code == MPI_SUCCESS) 2220: branch 1 never executed 2221: -: 1716: { 2222: #####: 1717: ErrorRing[ring_idx].prev_error = error2; 2223: #####: 1718: break; 2224: -: 1719: } 2225: -: 1720: 2226: #####: 1721: error_class = MPIR_ERR_GET_CLASS(error_code); 2227: -: 1722: 2228: #####: 1723: if (error_class == MPI_ERR_OTHER) 2230: branch 1 never executed 2231: -: 1724: { 2232: #####: 1725: ErrorRing[ring_idx].prev_error &= ~(ERROR_CLASS_MASK); 2233: #####: 1726: ErrorRing[ring_idx].prev_error |= error2_class; 2239: -: 1732:# endif 2240: -: 1733: 2241: #####: 1734: if (MPIR_ERR_GET_CLASS(error1_code) == MPI_ERR_OTHER) 2243: branch 1 never executed 2244: -: 1735: { 2245: #####: 1736: error1_code = (error1_code & ~(ERROR_CLASS_MASK)) | error2_class; 2246: -: 1737: } 2247: -: 1738: 2248: #####: 1739: return error1_code; 2290: -: 1776: } 2291: -: 1777:#endif 2292: #####: 1778: if (n > 0) { 2293: branch 0 never executed 2294: branch 1 never executed 2295: #####: 1779: MPIR_Err_chop_error_stack = TRUE; 2296: #####: 1780: MPIR_Err_chop_width = n; 2297: -: 1781: } 2298: #####: 1782: else if (n == 0) { 2300: branch 1 never executed 2301: -: 1783: /* Use the default width */ 2302: #####: 1784: MPIR_Err_chop_error_stack = TRUE; 2310: -: 1792:void MPIR_Err_print_stack(FILE * fp, int errcode) 2311: function MPIR_Err_print_stack called 0 returned 0% blocks executed 0% 2312: #####: 1793:{ 2313: -: 1794: error_ring_mutex_lock(); 2314: -: 1795: { 2315: #####: 1796: while (errcode != MPI_SUCCESS) { 2320: -: 1799: int generic_idx; 2321: -: 1800: 2322: #####: 1801: if (convertErrcodeToIndexes( errcode, &ring_idx, &ring_id, 2325: branch 2 never executed 2326: -: 1802: &generic_idx ) != 0) { 2327: #####: 1803: MPIU_Error_printf( 2329: -: 1804: "Invalid error code (%d) (error ring index %d invalid)\n", 2330: -: 1805: errcode, ring_idx ); 2331: #####: 1806: break; 2332: -: 1807: } 2333: -: 1808: 2334: #####: 1809: if (generic_idx < 0) 2336: branch 1 never executed 2337: -: 1810: { 2338: #####: 1811: break; 2339: -: 1812: } 2340: -: 1813: 2341: #####: 1814: if (ErrorRing[ring_idx].id == ring_id) 2343: branch 1 never executed 2344: -: 1815: { 2345: #####: 1816: fprintf(fp, "%s: %s\n", ErrorRing[ring_idx].location, 2346: call 0 never executed 2347: -: 1817: ErrorRing[ring_idx].msg); 2348: #####: 1818: errcode = ErrorRing[ring_idx].prev_error; 2350: -: 1820: else 2351: -: 1821: { 2352: #####: 1822: break; 2361: -: 1831: level of code (particularly when that code doesn't check for 2362: -: 1832: valid error codes!) is erroneous */ 2363: #####: 1833: if (errcode == MPI_SUCCESS) 2365: branch 1 never executed 2366: -: 1834: { 2367: #####: 1835: goto fn_exit; 2371: -: 1839: int generic_idx; 2372: -: 1840: 2373: #####: 1841: generic_idx = ((errcode & ERROR_GENERIC_MASK) >> ERROR_GENERIC_SHIFT) - 1; 2374: -: 1842: 2375: #####: 1843: if (generic_idx >= 0) 2377: branch 1 never executed 2378: -: 1844: { 2379: #####: 1845: fprintf(fp, "(unknown)(): %s\n", generic_err_msgs[generic_idx].long_name); 2380: call 0 never executed 2381: #####: 1846: goto fn_exit; 2386: -: 1851: int error_class; 2387: -: 1852: 2388: #####: 1853: error_class = ERROR_GET_CLASS(errcode); 2389: -: 1854: 2390: #####: 1855: if (error_class <= MPICH_ERR_LAST_CLASS) 2392: branch 1 never executed 2393: -: 1856: { 2394: #####: 1857: fprintf(fp, "(unknown)(): %s\n", get_class_msg(ERROR_GET_CLASS(errcode))); 2399: -: 1860: { 2400: -: 1861: /* FIXME: Not internationalized */ 2401: #####: 1862: fprintf(fp, "Error code contains an invalid class (%d)\n", error_class); 2432: branch 2 taken 100% 2433: -: 1887: &generic_idx ) != 0) { 2434: #####: 1888: MPIU_Error_printf( 2436: -: 1889: "Invalid error code (%d) (error ring index %d invalid)\n", 2437: -: 1890: errcode, ring_idx ); 2438: #####: 1891: break; 2442: branch 0 taken 0% (fallthrough) 2443: branch 1 taken 100% 2444: #####: 1895: break; 2455: -: 1903: else 2456: -: 1904: { 2457: #####: 1905: break; 2474: branch 2 taken 100% 2475: -: 1918: &generic_idx ) != 0) { 2476: #####: 1919: MPIU_Error_printf( 2484: branch 1 taken 100% 2485: -: 1925: { 2486: #####: 1926: break; 2524: branch 1 taken 100% 2525: -: 1952: { 2526: #####: 1953: cur_pos = ErrorRing[ring_idx].msg; 2527: #####: 1954: len = (int)strlen(cur_pos); 2528: call 0 never executed 2529: #####: 1955: if (len == 0 && maxlen > 0) { 2530: branch 0 never executed 2531: branch 1 never executed 2532: #####: 1956: *str++ = '\n'; 2533: #####: 1957: maxlen--; 2534: -: 1958: } 2535: #####: 1959: while (len) 2537: branch 1 never executed 2538: -: 1960: { 2539: #####: 1961: if (len >= MPIR_Err_chop_width - max_location_len) 2541: branch 1 never executed 2542: -: 1962: { 2543: #####: 1963: if (len > maxlen) 2544: branch 0 never executed 2545: branch 1 never executed 2546: #####: 1964: break; 2547: -: 1965: /* FIXME: Don't use Snprint to append a string ! */ 2548: #####: 1966: MPIU_Snprintf(str, MPIR_Err_chop_width - 1 - max_location_len, "%s", cur_pos); 2549: call 0 never executed 2550: #####: 1967: str[MPIR_Err_chop_width - 1 - max_location_len] = '\n'; 2551: #####: 1968: cur_pos += MPIR_Err_chop_width - 1 - max_location_len; 2552: #####: 1969: str += MPIR_Err_chop_width - max_location_len; 2553: #####: 1970: maxlen -= MPIR_Err_chop_width - max_location_len; 2554: #####: 1971: if (maxlen < max_location_len) 2555: branch 0 never executed 2556: branch 1 never executed 2557: #####: 1972: break; 2558: #####: 1973: for (i=0; i> ERROR_GENERIC_SHIFT) - 1; 2614: -: 2019: 2615: #####: 2020: if (generic_idx >= 0) 2620: -: 2023: /* FIXME: (Here and elsewhere) Make sure any string is 2621: -: 2024: non-null before you use it */ 2622: #####: 2025: p = generic_err_msgs[generic_idx].long_name; 2623: #####: 2026: if (!p) { p = ""; } 2624: branch 0 never executed 2625: branch 1 never executed 2626: #####: 2027: MPIU_Snprintf(str, maxlen, "(unknown)(): %s\n", p ); 2627: call 0 never executed 2628: #####: 2028: len = (int)strlen(str); 2629: call 0 never executed 2630: #####: 2029: maxlen -= len; 2631: #####: 2030: str += len; 2632: #####: 2031: goto fn_exit; 2637: -: 2036: int error_class; 2638: -: 2037: 2639: #####: 2038: error_class = ERROR_GET_CLASS(errcode); 2640: -: 2039: 2641: #####: 2040: if (error_class <= MPICH_ERR_LAST_CLASS) 2643: branch 1 never executed 2644: -: 2041: { 2645: #####: 2042: MPIU_Snprintf(str, maxlen, "(unknown)(): %s\n", 2647: call 1 never executed 2648: -: 2043: get_class_msg(ERROR_GET_CLASS(errcode))); 2649: #####: 2044: len = (int)strlen(str); 2650: call 0 never executed 2651: #####: 2045: maxlen -= len; 2652: #####: 2046: str += len; 2655: -: 2049: { 2656: -: 2050: /* FIXME: Not internationalized */ 2657: #####: 2051: MPIU_Snprintf(str, maxlen, 2659: -: 2052: "Error code contains an invalid class (%d)\n", 2660: -: 2053: error_class); 2661: #####: 2054: len = (int)strlen(str); 2662: call 0 never executed 2663: #####: 2055: maxlen -= len; 2664: #####: 2056: str += len; 2703: -: 2087: error_ring_mutex_lock(); 2704: -: 2088: { 2705: #####: 2089: while (errorcode != MPI_SUCCESS) { 2710: -: 2092: int generic_idx; 2711: -: 2093: 2712: #####: 2094: if (convertErrcodeToIndexes( errorcode, &ring_idx, 2716: -: 2095: &ring_id, 2717: -: 2096: &generic_idx ) != 0) { 2718: #####: 2097: MPIU_Error_printf( 2720: -: 2098: "Invalid error code (%d) (error ring index %d invalid)\n", 2721: -: 2099: errorcode, ring_idx ); 2722: #####: 2100: break; 2723: -: 2101: } 2724: -: 2102: 2725: #####: 2103: if (generic_idx < 0) { 2726: branch 0 never executed 2727: branch 1 never executed 2728: #####: 2104: break; 2729: -: 2105: } 2730: -: 2106: 2731: #####: 2107: if (ErrorRing[ring_idx].id == ring_id) { 2734: -: 2108: /* just keep clobbering old values until the 2735: -: 2109: end of the stack is reached */ 2736: #####: 2110: MPIU_Snprintf(msg, num_remaining, ", %s", 2737: call 0 never executed 2738: -: 2111: ErrorRing[ring_idx].msg); 2739: #####: 2112: msg[num_remaining - 1] = '\0'; 2740: #####: 2113: errorcode = ErrorRing[ring_idx].prev_error; 2741: -: 2114: } 2742: -: 2115: else { 2743: #####: 2116: break; 2752: branch 1 taken 0% 2753: -: 2124: 2754: #####: 2125: return 0; 254 line(s) not covered by tests in src/mpi/errhan/errutil.c.gcov All code covered by tests in src/mpi/errhan/mpiimpl.h.gcov Uncovered lines in src/mpi/errhan/dynerrutil.c.gcov 185: branch 0 taken 0% (fallthrough) 186: branch 1 taken 100% 187: #####: 156: MPIU_Free( (void*)(user_code_msgs[errcode]) ); 192: -: 160: else { 193: -: 161: /* FIXME : Unallocated error code? */ 194: #####: 162: MPIU_Free( str ); 203: branch 0 taken 0% (fallthrough) 204: branch 1 taken 100% 205: #####: 168: MPIU_Free( (void*)(user_class_msgs[errclass]) ); 210: -: 172: else { 211: -: 173: /* FIXME : Unallocated error code? */ 212: #####: 174: MPIU_Free( str ); 289: branch 0 taken 0% (fallthrough) 290: branch 1 taken 100% 291: #####: 243: MPIR_Init_err_dyncodes(); 343: branch 1 taken 100% 344: -: 290: /* Check for invalid error code */ 345: #####: 291: return 0; 6 line(s) not covered by tests in src/mpi/errhan/dynerrutil.c.gcov All code covered by tests in src/mpi/group/group_compare.c.gcov Uncovered lines in src/mpi/group/group_difference.c.gcov 179: branch 0 taken 0% (fallthrough) 180: branch 1 taken 100% 181: #####: 127: g2_idx = group_ptr2->lrank_to_lpid[g2_idx].next_lpid; 1 line(s) not covered by tests in src/mpi/group/group_difference.c.gcov All code covered by tests in src/mpi/group/group_excl.c.gcov All code covered by tests in src/mpi/group/group_free.c.gcov All code covered by tests in src/mpi/group/group_incl.c.gcov All code covered by tests in src/mpi/group/group_intersection.c.gcov All code covered by tests in src/mpi/group/group_range_excl.c.gcov All code covered by tests in src/mpi/group/group_range_incl.c.gcov All code covered by tests in src/mpi/group/group_rank.c.gcov All code covered by tests in src/mpi/group/group_size.c.gcov Uncovered lines in src/mpi/group/group_translate_ranks.c.gcov 212: branch 0 taken 0% (fallthrough) 213: branch 1 taken 100% 214: #####: 146: ranks2[i] = MPI_PROC_NULL; 215: #####: 147: continue; 2 line(s) not covered by tests in src/mpi/group/group_translate_ranks.c.gcov All code covered by tests in src/mpi/group/group_union.c.gcov All code covered by tests in src/mpi/group/grouputil.c.gcov Uncovered lines in src/mpi/init/abort.c.gcov 143: -: 107: { 144: -: 108: /* Use comm world if the communicator is not valid */ 145: #####: 109: comm_ptr = MPIR_Process.comm_world; 152: branch 1 taken 100% 153: -: 114: { 154: #####: 115: MPIU_Snprintf(comm_name, MPI_MAX_OBJECT_NAME, "comm=0x%X", comm); 2 line(s) not covered by tests in src/mpi/init/abort.c.gcov All code covered by tests in src/mpi/init/init.c.gcov All code covered by tests in src/mpi/init/initialized.c.gcov All code covered by tests in src/mpi/init/initthread.c.gcov All code covered by tests in src/mpi/init/ismain.c.gcov All code covered by tests in src/mpi/init/pthread.h.gcov Uncovered lines in src/mpi/init/finalize.c.gcov 242: -: 184: HANDLE_KIND_BUILTIN) ) { 243: -: 185: int in_use; 244: #####: 186: MPIR_Errhandler_release_ref( MPIR_Process.comm_self->errhandler, 250: call 5 never executed 251: -: 187: &in_use); 252: #####: 188: if (!in_use) { 253: branch 0 never executed 254: branch 1 never executed 255: #####: 189: MPIU_Handle_obj_free( &MPID_Errhandler_mem, 256: call 0 never executed 257: -: 190: MPIR_Process.comm_self->errhandler ); 258: #####: 191: MPIR_Process.comm_self->errhandler = NULL; 377: -: 299: /* Because this is a maintainer item, we won't check for 378: -: 300: errors in the delayStr */ 379: #####: 301: microseconds = 1000 * atoi( delayStr ); 5 line(s) not covered by tests in src/mpi/init/finalize.c.gcov All code covered by tests in src/mpi/init/finalized.c.gcov Uncovered lines in src/mpi/init/async.c.gcov 26: -: 21:static void progress_fn(void * data) 27: function progress_fn called 0 returned 0% blocks executed 0% 28: #####: 22:{ 29: -: 23:#if MPICH_THREAD_LEVEL >= MPI_THREAD_SERIALIZED 30: #####: 24: int mpi_errno = MPI_SUCCESS; 51: -: 45: MPIU_THREADPRIV_GET; 52: -: 46: 53: #####: 47: MPIR_Nest_incr(); 54: #####: 48: mpi_errno = NMPI_Recv(NULL, 0, MPI_CHAR, 0, 0, progress_comm, MPI_STATUS_IGNORE); 55: call 0 never executed 56: #####: 49: MPIU_Assert(!mpi_errno); 59: call 2 never executed 60: call 3 never executed 61: #####: 50: MPIR_Nest_decr(); 62: -: 51: 63: -: 52: /* Send a signal to the main thread saying we are done */ 64: #####: 53: MPIU_Thread_mutex_lock(&progress_mutex, &mpi_errno); 65: call 0 never executed 66: #####: 54: MPIU_Assert(!mpi_errno); 70: call 3 never executed 71: -: 55: 72: #####: 56: progress_thread_done = 1; 73: -: 57: 74: #####: 58: MPIU_Thread_mutex_unlock(&progress_mutex, &mpi_errno); 75: call 0 never executed 76: #####: 59: MPIU_Assert(!mpi_errno); 80: call 3 never executed 81: -: 60: 82: #####: 61: MPIU_Thread_cond_signal(&progress_cond, &mpi_errno); 83: call 0 never executed 84: #####: 62: MPIU_Assert(!mpi_errno); 102: -: 76:int MPIR_Init_async_thread(void) 103: function MPIR_Init_async_thread called 0 returned 0% blocks executed 0% 104: #####: 77:{ 105: #####: 78: int mpi_errno = MPI_SUCCESS; 113: -: 86: 114: -: 87: /* Dup comm world for the progress thread */ 115: #####: 88: MPIR_Nest_incr(); 116: #####: 89: mpi_errno = NMPI_Comm_dup(MPI_COMM_SELF, &progress_comm); 117: call 0 never executed 118: #####: 90: MPIU_Assert(!mpi_errno); 121: call 2 never executed 122: call 3 never executed 123: #####: 91: MPIR_Nest_decr(); 124: -: 92: 125: #####: 93: MPIU_Thread_cond_create(&progress_cond, &mpi_errno); 126: call 0 never executed 127: #####: 94: MPIU_Assert(!mpi_errno); 131: call 3 never executed 132: -: 95: 133: #####: 96: MPIU_Thread_mutex_create(&progress_mutex, &mpi_errno); 134: call 0 never executed 135: #####: 97: MPIU_Assert(!mpi_errno); 139: call 3 never executed 140: -: 98: 141: #####: 99: MPIU_Thread_create((MPIU_Thread_func_t) progress_fn, NULL, &progress_thread_id, &mpi_errno); 142: call 0 never executed 143: #####: 100: MPIU_Assert(!mpi_errno); 150: -: 103: 151: -: 104:#endif /* MPICH_THREAD_LEVEL >= MPI_THREAD_SERIALIZED */ 152: #####: 105: return mpi_errno; 159: -: 112:int MPIR_Finalize_async_thread(void) 160: function MPIR_Finalize_async_thread called 0 returned 0% blocks executed 0% 161: #####: 113:{ 162: #####: 114: int mpi_errno = MPI_SUCCESS; 169: -: 121: MPIU_THREADPRIV_GET; 170: -: 122: 171: #####: 123: MPIR_Nest_incr(); 172: #####: 124: mpi_errno = NMPI_Send(NULL, 0, MPI_CHAR, 0, 0, progress_comm); 173: call 0 never executed 174: #####: 125: MPIU_Assert(!mpi_errno); 177: call 2 never executed 178: call 3 never executed 179: #####: 126: MPIR_Nest_decr(); 183: -: 130:#endif 184: -: 131: 185: #####: 132: MPIU_Thread_mutex_lock(&progress_mutex, &mpi_errno); 186: call 0 never executed 187: #####: 133: MPIU_Assert(!mpi_errno); 191: call 3 never executed 192: -: 134: 193: #####: 135: while (!progress_thread_done) { 194: branch 0 never executed 195: branch 1 never executed 196: #####: 136: MPIU_Thread_cond_wait(&progress_cond, &progress_mutex, &mpi_errno); 198: branch 1 never executed 199: branch 2 never executed 200: #####: 137: MPIU_Assert(!mpi_errno); 205: -: 138: } 206: -: 139: 207: #####: 140: MPIU_Thread_mutex_unlock(&progress_mutex, &mpi_errno); 208: call 0 never executed 209: #####: 141: MPIU_Assert(!mpi_errno); 217: -: 145:#endif 218: -: 146: 219: #####: 147: MPIU_Thread_cond_destroy(&progress_cond, &mpi_errno); 220: call 0 never executed 221: #####: 148: MPIU_Assert(!mpi_errno); 225: call 3 never executed 226: -: 149: 227: #####: 150: MPIU_Thread_mutex_destroy(&progress_mutex, &mpi_errno); 228: call 0 never executed 229: #####: 151: MPIU_Assert(!mpi_errno); 236: -: 154: 237: -: 155:#endif /* MPICH_THREAD_LEVEL >= MPI_THREAD_SERIALIZED */ 238: #####: 156: return mpi_errno; 44 line(s) not covered by tests in src/mpi/init/async.c.gcov Uncovered lines in src/mpi/init/stdlib.h.gcov 289: -: 284:__NTH (atoi (__const char *__nptr)) 290: function atoi called 0 returned 0% blocks executed 0% 291: #####: 285:{ 292: #####: 286: return (int) strtol (__nptr, (char **) NULL, 10); 2 line(s) not covered by tests in src/mpi/init/stdlib.h.gcov All code covered by tests in src/mpi/init/querythread.c.gcov All code covered by tests in src/mpi/misc/getpname.c.gcov All code covered by tests in src/mpi/misc/pcontrol.c.gcov All code covered by tests in src/mpi/misc/version.c.gcov All code covered by tests in src/mpi/pt2pt/ssend.c.gcov All code covered by tests in src/mpi/pt2pt/bsend.c.gcov All code covered by tests in src/mpi/pt2pt/bsend_init.c.gcov All code covered by tests in src/mpi/pt2pt/bufattach.c.gcov All code covered by tests in src/mpi/pt2pt/buffree.c.gcov All code covered by tests in src/mpi/pt2pt/cancel.c.gcov Uncovered lines in src/mpi/pt2pt/greq_start.c.gcov 290: -: 259: } 291: -: 260: else { 292: #####: 261: class_ptr->next = MPIR_Grequest_class_list; 408: -: 360: void *extra_state, MPI_Request *request ) 409: function PMPIX_Grequest_start called 0 returned 0% blocks executed 0% 410: #####: 361:{ 412: -: 363: MPID_Request *lrequest_ptr; 413: -: 364: 414: #####: 365: mpi_errno = MPI_Grequest_start(query_fn, free_fn, cancel_fn, 416: -: 366: extra_state, request); 417: -: 367: 418: #####: 368: if (mpi_errno == MPI_SUCCESS) 420: branch 1 never executed 421: -: 369: { 422: #####: 370: MPID_Request_get_ptr(*request, lrequest_ptr); 425: branch 2 never executed 426: call 3 never executed 427: #####: 371: lrequest_ptr->poll_fn = poll_fn; 428: #####: 372: lrequest_ptr->wait_fn = wait_fn; 429: -: 373: } 430: -: 374: 431: #####: 375: return mpi_errno; 8 line(s) not covered by tests in src/mpi/pt2pt/greq_start.c.gcov All code covered by tests in src/mpi/pt2pt/greq_complete.c.gcov All code covered by tests in src/mpi/pt2pt/ibsend.c.gcov All code covered by tests in src/mpi/pt2pt/iprobe.c.gcov All code covered by tests in src/mpi/pt2pt/irecv.c.gcov All code covered by tests in src/mpi/pt2pt/irsend.c.gcov All code covered by tests in src/mpi/pt2pt/isend.c.gcov All code covered by tests in src/mpi/pt2pt/issend.c.gcov All code covered by tests in src/mpi/pt2pt/probe.c.gcov All code covered by tests in src/mpi/pt2pt/recv.c.gcov All code covered by tests in src/mpi/pt2pt/recv_init.c.gcov Uncovered lines in src/mpi/pt2pt/request_free.c.gcov 174: -: 131: { 175: -: 132: /* This is needed for persistent Bsend requests */ 176: #####: 133: mpi_errno = MPIR_Grequest_free( 1 line(s) not covered by tests in src/mpi/pt2pt/request_free.c.gcov Uncovered lines in src/mpi/pt2pt/request_get_status.c.gcov 149: branch 1 taken 100% 150: -: 109: /* request not complete. poke the progress engine. Req #3130 */ 151: #####: 110: mpi_errno = MPID_Progress_test(); 170: -: 118: case MPID_REQUEST_SEND: 171: -: 119: { 172: #####: 120: if (status != MPI_STATUS_IGNORE) 174: branch 1 never executed 175: -: 121: { 176: #####: 122: status->cancelled = request_ptr->status.cancelled; 177: -: 123: } 178: #####: 124: mpi_errno = request_ptr->status.MPI_ERROR; 179: #####: 125: break; 191: -: 135: case MPID_PREQUEST_SEND: 192: -: 136: { 193: #####: 137: MPID_Request * prequest_ptr = request_ptr->partner_request; 194: -: 138: 195: #####: 139: if (prequest_ptr != NULL) 197: branch 1 never executed 198: -: 140: { 199: #####: 141: if (prequest_ptr->kind != MPID_UREQUEST) 201: branch 1 never executed 202: -: 142: { 203: #####: 143: if (status != MPI_STATUS_IGNORE) 205: branch 1 never executed 206: -: 144: { 207: #####: 145: status->cancelled = request_ptr->status.cancelled; 208: -: 146: } 209: #####: 147: mpi_errno = prequest_ptr->status.MPI_ERROR; 214: -: 152: MPIU_THREADPRIV_DECL; 215: -: 153: MPIU_THREADPRIV_GET; 216: #####: 154: MPIR_Nest_incr(); 218: -: 156: int rc; 219: -: 157: 220: #####: 158: rc = MPIR_Grequest_query(prequest_ptr); 221: call 0 never executed 222: #####: 159: if (mpi_errno == MPI_SUCCESS) 224: branch 1 never executed 225: -: 160: { 226: #####: 161: mpi_errno = rc; 227: -: 162: } 228: #####: 163: if (status != MPI_STATUS_IGNORE) 230: branch 1 never executed 231: -: 164: { 232: #####: 165: status->cancelled = prequest_ptr->status.cancelled; 233: -: 166: } 234: #####: 167: if (mpi_errno == MPI_SUCCESS) 236: branch 1 never executed 237: -: 168: { 238: #####: 169: mpi_errno = prequest_ptr->status.MPI_ERROR; 239: -: 170: } 240: -: 171: } 241: #####: 172: MPIR_Nest_decr(); 244: -: 175: else 245: -: 176: { 246: #####: 177: if (request_ptr->status.MPI_ERROR != MPI_SUCCESS) 250: -: 179: /* if the persistent request failed to start then 251: -: 180: make the error code available */ 252: #####: 181: if (status != MPI_STATUS_IGNORE) 254: branch 1 never executed 255: -: 182: { 256: #####: 183: status->cancelled = request_ptr->status.cancelled; 257: -: 184: } 258: #####: 185: mpi_errno = request_ptr->status.MPI_ERROR; 260: -: 187: else 261: -: 188: { 262: #####: 189: MPIR_Status_set_empty(status); 271: -: 196: case MPID_PREQUEST_RECV: 272: -: 197: { 273: #####: 198: MPID_Request * prequest_ptr = request_ptr->partner_request; 274: -: 199: 275: #####: 200: if (prequest_ptr != NULL) 277: branch 1 never executed 278: -: 201: { 279: #####: 202: MPIR_Request_extract_status(prequest_ptr, status); 280: branch 0 never executed 281: branch 1 never executed 282: #####: 203: mpi_errno = prequest_ptr->status.MPI_ERROR; 286: -: 207: /* if the persistent request failed to start then 287: -: 208: make the error code available */ 288: #####: 209: mpi_errno = request_ptr->status.MPI_ERROR; 289: #####: 210: MPIR_Status_set_empty(status); 299: -: 218: MPIU_THREADPRIV_DECL; 300: -: 219: MPIU_THREADPRIV_GET; 301: #####: 220: MPIR_Nest_incr(); 303: -: 222: int rc; 304: -: 223: 305: #####: 224: rc = MPIR_Grequest_query(request_ptr); 306: call 0 never executed 307: #####: 225: if (mpi_errno == MPI_SUCCESS) 309: branch 1 never executed 310: -: 226: { 311: #####: 227: mpi_errno = rc; 312: -: 228: } 313: #####: 229: if (status != MPI_STATUS_IGNORE) 315: branch 1 never executed 316: -: 230: { 317: #####: 231: status->cancelled = request_ptr->status.cancelled; 318: -: 232: } 319: #####: 233: MPIR_Request_extract_status(request_ptr, status); 321: branch 1 never executed 322: -: 234: } 323: #####: 235: MPIR_Nest_decr(); 334: -: 246: else 335: -: 247: { 336: #####: 248: *flag = FALSE; 40 line(s) not covered by tests in src/mpi/pt2pt/request_get_status.c.gcov All code covered by tests in src/mpi/pt2pt/rsend.c.gcov All code covered by tests in src/mpi/pt2pt/rsend_init.c.gcov All code covered by tests in src/mpi/pt2pt/send.c.gcov All code covered by tests in src/mpi/pt2pt/send_init.c.gcov All code covered by tests in src/mpi/pt2pt/sendrecv.c.gcov All code covered by tests in src/mpi/pt2pt/sendrecv_rep.c.gcov All code covered by tests in src/mpi/pt2pt/status_set_cancelled.c.gcov All code covered by tests in src/mpi/pt2pt/start.c.gcov All code covered by tests in src/mpi/pt2pt/ssend_init.c.gcov Uncovered lines in src/mpi/pt2pt/startall.c.gcov 126: branch 1 taken 100% 127: -: 96: { 128: #####: 97: MPIU_CHKLMEM_MALLOC_ORJUMP(request_ptrs, MPID_Request **, count * sizeof(MPID_Request *), mpi_errno, "request pointers"); 205: branch 1 taken 100% 206: -: 135: { 207: #####: 136: MPIU_CHKLMEM_FREEALL(); 2 line(s) not covered by tests in src/mpi/pt2pt/startall.c.gcov Uncovered lines in src/mpi/pt2pt/test.c.gcov 176: branch 3 taken 100% 177: -: 126: { 178: #####: 127: mpi_errno = (request_ptr->poll_fn)(request_ptr->grequest_extra_state, 1 line(s) not covered by tests in src/mpi/pt2pt/test.c.gcov All code covered by tests in src/mpi/pt2pt/test_cancelled.c.gcov Uncovered lines in src/mpi/pt2pt/testall.c.gcov 170: branch 1 taken 100% 171: -: 130: { 172: #####: 131: MPIU_CHKLMEM_MALLOC_ORJUMP(request_ptrs, MPID_Request **, 242: -: 167: request_ptrs[i]->poll_fn != NULL) 243: -: 168: { 244: #####: 169: mpi_errno = (request_ptrs[i]->poll_fn)(request_ptrs[i]->grequest_extra_state, 301: -: 201: else 302: -: 202: { 303: #####: 203: status_ptr->MPI_ERROR = MPI_SUCCESS; 307: -: 207: else 308: -: 208: { 309: #####: 209: if (mpi_errno == MPI_ERR_IN_STATUS && array_of_statuses != MPI_STATUSES_IGNORE) 311: branch 1 never executed 312: -: 210: { 313: #####: 211: array_of_statuses[i].MPI_ERROR = MPI_ERR_PENDING; 329: branch 1 taken 100% 330: -: 222: { 331: #####: 223: array_of_statuses[i].MPI_ERROR = MPI_SUCCESS; 349: branch 1 taken 100% 350: -: 238: { 351: #####: 239: MPIU_CHKLMEM_FREEALL(); 7 line(s) not covered by tests in src/mpi/pt2pt/testall.c.gcov Uncovered lines in src/mpi/pt2pt/testany.c.gcov 158: branch 1 taken 100% 159: -: 115: { 160: #####: 116: MPIU_CHKLMEM_MALLOC_ORJUMP(request_ptrs, MPID_Request **, count * sizeof(MPID_Request *), mpi_errno, "request pointers"); 252: -: 168: request_ptrs[i]->poll_fn != NULL) 253: -: 169: { 254: #####: 170: mpi_errno = (request_ptrs[i]->poll_fn)(request_ptrs[i]->grequest_extra_state, 279: -: 185: else 280: -: 186: { 281: #####: 187: n_inactive += 1; 288: branch 1 taken 100% 289: -: 193: { 290: #####: 194: *flag = TRUE; 291: #####: 195: *index = MPI_UNDEFINED; 300: branch 1 taken 100% 301: -: 203: { 302: #####: 204: MPIU_CHKLMEM_FREEALL(); 6 line(s) not covered by tests in src/mpi/pt2pt/testany.c.gcov Uncovered lines in src/mpi/pt2pt/testsome.c.gcov 165: branch 1 taken 100% 166: -: 122: { 167: #####: 123: MPIU_CHKLMEM_MALLOC_ORJUMP(request_ptrs, MPID_Request **, incount * sizeof(MPID_Request *), mpi_errno, "request pointers"); 249: -: 169: request_ptrs[i]->poll_fn != NULL) 250: -: 170: { 251: #####: 171: mpi_errno = (request_ptrs[i]->poll_fn)(request_ptrs[i]->grequest_extra_state, 294: -: 198: else 295: -: 199: { 296: #####: 200: request_ptrs[i] = NULL; 297: #####: 201: n_inactive += 1; 332: branch 1 taken 100% 333: -: 225: { 334: #####: 226: *outcount = MPI_UNDEFINED; 346: branch 1 taken 100% 347: -: 235: { 348: #####: 236: MPIU_CHKLMEM_FREEALL(); 6 line(s) not covered by tests in src/mpi/pt2pt/testsome.c.gcov All code covered by tests in src/mpi/pt2pt/wait.c.gcov Uncovered lines in src/mpi/pt2pt/waitall.c.gcov 260: branch 1 taken 100% 261: -: 183: { 262: #####: 184: if (!ignoring_statuses) 263: branch 0 never executed 264: branch 1 never executed 265: #####: 185: array_of_statuses[i].MPI_ERROR = MPI_SUCCESS; 333: -: 229: { 334: -: 230: /* either the user specified MPI_REQUEST_NULL, or this is a completed greq */ 335: #####: 231: array_of_statuses[j].MPI_ERROR = MPI_SUCCESS; 3 line(s) not covered by tests in src/mpi/pt2pt/waitall.c.gcov Uncovered lines in src/mpi/pt2pt/waitany.c.gcov 233: -: 163: { 234: -: 164: /* this is a generalized request; make progress on it */ 235: #####: 165: mpi_errno = (request_ptrs[i]->poll_fn)(request_ptrs[i]->grequest_extra_state, status); 236: call 0 never executed 237: #####: 166: if (mpi_errno != MPI_SUCCESS) goto fn_progress_end_fail; 263: branch 1 taken 100% 264: -: 184: { 265: #####: 185: *index = MPI_UNDEFINED; 266: -: 186: /* status is set to empty by MPIR_Request_complete */ 267: #####: 187: goto break_l1; 313: 3079: 219: return mpi_errno; 314: -: 220: 315: #####: 221: fn_progress_end_fail: 5 line(s) not covered by tests in src/mpi/pt2pt/waitany.c.gcov Uncovered lines in src/mpi/pt2pt/waitsome.c.gcov 183: branch 1 taken 100% 184: -: 140: { 185: #####: 141: MPIU_CHKLMEM_MALLOC_ORJUMP(request_ptrs, MPID_Request **, incount * sizeof(MPID_Request *), mpi_errno, "request pointers"); 312: -: 222: else 313: -: 223: { 314: #####: 224: request_ptrs[i] = NULL; 315: #####: 225: n_inactive += 1; 352: branch 1 taken 100% 353: -: 251: { 354: #####: 252: *outcount = MPI_UNDEFINED; 355: #####: 253: break; 377: branch 1 taken 100% 378: -: 271: { 379: #####: 272: MPIU_CHKLMEM_FREEALL(); 6 line(s) not covered by tests in src/mpi/pt2pt/waitsome.c.gcov Uncovered lines in src/mpi/pt2pt/bsendutil.c.gcov 265: -: 234: else 266: -: 235: { 267: #####: 236: packsize = count; 305: -: 266: else 306: -: 267: { 307: #####: 268: MPIU_Memcpy(p->msg.msgbuf, buf, count); 331: call 23 never executed 332: call 24 never executed 333: #####: 269: p->msg.count = count; 488: -: 395: } 489: -: 396: else { 490: #####: 397: p->next = 0; 601: branch 0 taken 0% 602: branch 1 taken 100% (fallthrough) 603: #####: 488: next_pending = pending->next; 604: -: 489: /* Retry sending this item */ 605: -: 490: /* FIXME */ 606: #####: 491: pending = next_pending; 698: branch 0 taken 0% (fallthrough) 699: branch 1 taken 100% 700: #####: 571: prev->next = p->next; 7 line(s) not covered by tests in src/mpi/pt2pt/bsendutil.c.gcov Uncovered lines in src/mpi/pt2pt/mpiimpl.h.gcov 115: -: 110:static MPIU_DBG_INLINE_KEYWORD void MPIUI_Memcpy(void * dst, const void * src, size_t len) 116: function MPIUI_Memcpy called 0 returned 0% blocks executed 0% 117: #####: 111:{ 118: #####: 112: memcpy(dst, src, len); 2 line(s) not covered by tests in src/mpi/pt2pt/mpiimpl.h.gcov Uncovered lines in src/mpi/pt2pt/mpir_request.c.gcov 169: -: 114: /* if the persistent request failed to start then make the 170: -: 115: error code available */ 171: #####: 116: if (status != MPI_STATUS_IGNORE) 173: branch 1 never executed 174: -: 117: { 175: #####: 118: status->cancelled = FALSE; 176: -: 119: } 177: #####: 120: mpi_errno = request_ptr->status.MPI_ERROR; 338: -: 242: case MPID_PREQUEST_SEND: 339: -: 243: { 340: #####: 244: if (request_ptr->partner_request != NULL) 342: branch 1 never executed 343: -: 245: { 344: #####: 246: if (request_ptr->partner_request->kind == MPID_UREQUEST) 347: -: 247: { 348: -: 248: /* This is needed for persistent Bsend requests */ 349: #####: 249: mpi_errno = MPIR_Grequest_query( 351: -: 250: request_ptr->partner_request); 352: -: 251: } 353: #####: 252: if (mpi_errno == MPI_SUCCESS) 355: branch 1 never executed 356: -: 253: { 357: #####: 254: mpi_errno = request_ptr->partner_request->status.MPI_ERROR; 360: -: 257: else 361: -: 258: { 362: #####: 259: mpi_errno = request_ptr->status.MPI_ERROR; 368: -: 265: case MPID_PREQUEST_RECV: 369: -: 266: { 370: #####: 267: if (request_ptr->partner_request != NULL) 372: branch 1 never executed 373: -: 268: { 374: #####: 269: mpi_errno = request_ptr->partner_request->status.MPI_ERROR; 376: -: 271: else 377: -: 272: { 378: #####: 273: mpi_errno = request_ptr->status.MPI_ERROR; 390: -: 285: is called */ 391: -: 286: /* Note that we've acquired the thread private storage above */ 392: #####: 287: MPIR_Nest_incr(); 393: -: 288: 394: #####: 289: switch (request_ptr->greq_lang) 401: -: 293: case MPID_LANG_CXX: 402: -: 294:#endif 403: #####: 295: rc = (request_ptr->query_fn)( 405: -: 296: request_ptr->grequest_extra_state, 406: -: 297: &request_ptr->status); 407: #####: 298: MPIU_ERR_CHKANDSTMT1((rc != MPI_SUCCESS), mpi_errno, 416: -: 304: { 417: -: 305: MPI_Fint ierr; 418: #####: 306: ((MPIR_Grequest_f77_query_function*)(request_ptr->query_fn))( 420: -: 307: request_ptr->grequest_extra_state, &request_ptr->status, 421: -: 308: &ierr ); 422: #####: 309: rc = (int) ierr; 423: #####: 310: MPIU_ERR_CHKANDSTMT1((rc != MPI_SUCCESS), mpi_errno, 443: -: 326: } 444: -: 327: 445: #####: 328: MPIR_Nest_decr(); 446: #####: 329: break; 514: -: 383: MPI_Fint ierr; 515: -: 384: 516: #####: 385: ((MPIR_Grequest_f77_cancel_function *)(request_ptr->cancel_fn))( 517: call 0 never executed 518: -: 386: request_ptr->grequest_extra_state, &complete, &ierr); 519: #####: 387: rc = (int) ierr; 520: #####: 388: MPIU_ERR_CHKANDSTMT1((rc != MPI_SUCCESS), mpi_errno, MPI_ERR_OTHER, 719: branch 0 taken 0% (fallthrough) 720: branch 1 taken 100% 721: #####: 538: if (request_ptrs[i+1] == NULL || 726: -: 539: (request_ptrs[i]->greq_class != 727: -: 540: request_ptrs[i+1]->greq_class) ) 728: #####: 541: n_classes += 1; 758: -: 556: request_ptrs[i]->poll_fn != NULL) 759: -: 557: { 760: #####: 558: mpi_errno = (request_ptrs[i]->poll_fn)(request_ptrs[i]->grequest_extra_state, &(array_of_statuses[i])); 912: -: 666: progress engine should permit the other thread to run at some 913: -: 667: point. */ 914: #####: 668: while (*request_ptrs[i]->cc_ptr != 0) 916: branch 1 never executed 917: -: 669: { 918: #####: 670: mpi_error = MPID_Progress_wait(&progress_state); 919: call 0 never executed 920: #####: 671: if (mpi_error != MPI_SUCCESS) 30 line(s) not covered by tests in src/mpi/pt2pt/mpir_request.c.gcov All code covered by tests in src/mpi/rma/accumulate.c.gcov All code covered by tests in src/mpi/rma/free_mem.c.gcov All code covered by tests in src/mpi/rma/get.c.gcov All code covered by tests in src/mpi/rma/win_complete.c.gcov All code covered by tests in src/mpi/rma/win_create.c.gcov All code covered by tests in src/mpi/rma/win_free.c.gcov All code covered by tests in src/mpi/rma/win_get_name.c.gcov All code covered by tests in src/mpi/rma/win_lock.c.gcov All code covered by tests in src/mpi/rma/win_set_name.c.gcov All code covered by tests in src/mpi/rma/win_start.c.gcov All code covered by tests in src/mpi/rma/win_wait.c.gcov All code covered by tests in src/mpi/rma/alloc_mem.c.gcov All code covered by tests in src/mpi/rma/put.c.gcov All code covered by tests in src/mpi/rma/win_fence.c.gcov All code covered by tests in src/mpi/rma/win_get_group.c.gcov All code covered by tests in src/mpi/rma/win_post.c.gcov All code covered by tests in src/mpi/rma/win_unlock.c.gcov All code covered by tests in src/mpi/rma/win_test.c.gcov Uncovered lines in src/mpi/spawn/comm_disconnect.c.gcov 145: -: 109: MPID_Progress_state progress_state; 146: -: 110: 147: #####: 111: MPID_Progress_start(&progress_state); 148: #####: 112: while (MPIU_Object_get_ref(comm_ptr) > 1) 150: branch 1 never executed 151: -: 113: { 152: #####: 114: mpi_errno = MPID_Progress_wait(&progress_state); 3 line(s) not covered by tests in src/mpi/spawn/comm_disconnect.c.gcov All code covered by tests in src/mpi/spawn/comm_get_parent.c.gcov Uncovered lines in src/mpi/spawn/comm_join.c.gcov 259: 2: 186: return mpi_errno; 260: -: 187: 261: #####: 189: MPIR_Nest_decr(); 1 line(s) not covered by tests in src/mpi/spawn/comm_join.c.gcov All code covered by tests in src/mpi/spawn/comm_spawn.c.gcov All code covered by tests in src/mpi/spawn/comm_spawn_multiple.c.gcov All code covered by tests in src/mpi/spawn/lookup_name.c.gcov All code covered by tests in src/mpi/spawn/publish_name.c.gcov All code covered by tests in src/mpi/spawn/unpublish_name.c.gcov All code covered by tests in src/mpi/spawn/open_port.c.gcov All code covered by tests in src/mpi/spawn/close_port.c.gcov All code covered by tests in src/mpi/spawn/comm_connect.c.gcov All code covered by tests in src/mpi/spawn/comm_accept.c.gcov All code covered by tests in src/mpi/timer/wtime.c.gcov All code covered by tests in src/mpi/timer/wtick.c.gcov Uncovered lines in src/mpi/timer/mpidtime.c.gcov 127: -: 118:void MPID_Wtime_acc( MPID_Time_t *t1, MPID_Time_t *t2, MPID_Time_t *t3 ) 128: function MPID_Wtime_acc called 0 returned 0% blocks executed 0% 129: #####: 119:{ 130: -: 120: int usec, sec; 131: -: 121: 132: #####: 122: usec = t2->tv_usec - t1->tv_usec; 133: #####: 123: sec = t2->tv_sec - t1->tv_sec; 134: #####: 124: t3->tv_usec += usec; 135: #####: 125: t3->tv_sec += sec; 136: -: 126: /* Handle carry to the integer seconds field */ 137: #####: 127: if (t3->tv_usec > 1.0e6) { 138: branch 0 never executed 139: branch 1 never executed 140: #####: 128: t3->tv_usec -= 1.0e6; 141: #####: 129: t3->tv_sec++; 8 line(s) not covered by tests in src/mpi/timer/mpidtime.c.gcov All code covered by tests in src/mpi/topo/cart_coords.c.gcov All code covered by tests in src/mpi/topo/cart_get.c.gcov Uncovered lines in src/mpi/topo/cart_map.c.gcov 63: -: 50: "**topotoolarge", 64: -: 51: "**topotoolarge %d %d", size, nranks ); 65: #####: 52: return mpi_errno; 205: branch 2 never executed 206: branch 3 never executed 207: #####: 150: mpi_errno = comm_ptr->topo_fns->cartMap( comm_ptr, ndims, 2 line(s) not covered by tests in src/mpi/topo/cart_map.c.gcov All code covered by tests in src/mpi/topo/cart_shift.c.gcov Uncovered lines in src/mpi/topo/cart_sub.c.gcov 278: -: 177: } 279: -: 178: else { 280: #####: 179: toponew_ptr->topo.cart.dims = 0; 281: #####: 180: toponew_ptr->topo.cart.periodic = 0; 282: #####: 181: toponew_ptr->topo.cart.position = 0; 3 line(s) not covered by tests in src/mpi/topo/cart_sub.c.gcov All code covered by tests in src/mpi/topo/graph_get.c.gcov All code covered by tests in src/mpi/topo/graph_nbr.c.gcov Uncovered lines in src/mpi/topo/graphcreate.c.gcov 67: -: 59: /* Allow the cart map routine to remap the assignment of ranks to 68: -: 60: processes */ 69: #####: 61: MPIR_Nest_incr(); 70: #####: 62: mpi_errno = NMPI_Graph_map( comm_ptr->handle, nnodes, 75: -: 66: the ranks (including the related internals, such as the connection 76: -: 67: tables */ 77: #####: 68: if (mpi_errno == 0) { 78: branch 0 never executed 79: branch 1 never executed 80: #####: 69: mpi_errno = NMPI_Comm_split( comm_ptr->handle, 84: -: 70: nrank == MPI_UNDEFINED ? MPI_UNDEFINED : 1, 85: -: 71: nrank, &ncomm ); 86: #####: 72: if (!mpi_errno) { 87: branch 0 never executed 88: branch 1 never executed 89: #####: 73: MPID_Comm_get_ptr( ncomm, newcomm_ptr ); 95: -: 74: } 96: -: 75: } 97: #####: 76: MPIR_Nest_decr(); 113: branch 0 taken 0% (fallthrough) 114: branch 1 taken 100% 115: #####: 89: *comm_graph = MPI_COMM_NULL; 116: #####: 90: goto fn_exit; 472: branch 3 never executed 473: -: 327: comm_ptr->topo_fns->graphCreate != NULL) { 474: #####: 328: mpi_errno = comm_ptr->topo_fns->graphCreate( comm_ptr, nnodes, 10 line(s) not covered by tests in src/mpi/topo/graphcreate.c.gcov All code covered by tests in src/mpi/topo/graphnbrcnt.c.gcov All code covered by tests in src/mpi/topo/cartdim_get.c.gcov All code covered by tests in src/mpi/topo/dist_gr_create_adj.c.gcov Uncovered lines in src/mpi/topo/dist_gr_create.c.gcov 604: branch 0 taken 0% (fallthrough) 605: branch 1 taken 100% 606: #####: 320: in_capacity *= 2; 607: #####: 321: MPIU_REALLOC_ORJUMP(dist_graph_ptr->in, in_capacity*sizeof(int), mpi_errno); 612: branch 4 never executed 613: call 5 never executed 614: #####: 322: if (weights != MPI_UNWEIGHTED) 615: branch 0 never executed 616: branch 1 never executed 617: #####: 323: MPIU_REALLOC_ORJUMP(dist_graph_ptr->in_weights, in_capacity*sizeof(int), mpi_errno); 670: branch 0 taken 0% (fallthrough) 671: branch 1 taken 100% 672: #####: 350: out_capacity *= 2; 673: #####: 351: MPIU_REALLOC_ORJUMP(dist_graph_ptr->out, out_capacity*sizeof(int), mpi_errno); 678: branch 4 never executed 679: call 5 never executed 680: #####: 352: if (weights != MPI_UNWEIGHTED) 681: branch 0 never executed 682: branch 1 never executed 683: #####: 353: MPIU_REALLOC_ORJUMP(dist_graph_ptr->out_weights, out_capacity*sizeof(int), mpi_errno); 778: 320: 393: return mpi_errno; 779: -: 394: 780: #####: 396: if (dist_graph_ptr && dist_graph_ptr->in) 783: branch 2 never executed 784: branch 3 never executed 785: #####: 397: MPIU_Free(dist_graph_ptr->in); 786: call 0 never executed 787: #####: 398: if (dist_graph_ptr && dist_graph_ptr->in_weights) 790: branch 2 never executed 791: branch 3 never executed 792: #####: 399: MPIU_Free(dist_graph_ptr->in_weights); 793: call 0 never executed 794: #####: 400: if (dist_graph_ptr && dist_graph_ptr->out) 797: branch 2 never executed 798: branch 3 never executed 799: #####: 401: MPIU_Free(dist_graph_ptr->out); 800: call 0 never executed 801: #####: 402: if (dist_graph_ptr && dist_graph_ptr->out_weights) 804: branch 2 never executed 805: branch 3 never executed 806: #####: 403: MPIU_Free(dist_graph_ptr->out_weights); 807: call 0 never executed 808: #####: 404: MPIU_CHKPMEM_REAP(); 17 line(s) not covered by tests in src/mpi/topo/dist_gr_create.c.gcov All code covered by tests in src/mpi/topo/dist_gr_neighb_count.c.gcov Uncovered lines in src/mpi/topo/topoutil.c.gcov 49: branch 0 taken 100% (fallthrough) 50: branch 1 taken 0% 51: #####: 40: return 0; 343: -: 193: /* Return mpi_errno in case one of the copy array functions failed */ 344: 360: 194: return mpi_errno; 345: #####: 196: MPIU_CHKPMEM_REAP(); 2 line(s) not covered by tests in src/mpi/topo/topoutil.c.gcov Uncovered lines in src/mpi/topo/cart_create.c.gcov 473: branch 2 never executed 474: branch 3 never executed 475: #####: 291: mpi_errno = comm_ptr->topo_fns->cartCreate( comm_ptr, ndims, 1 line(s) not covered by tests in src/mpi/topo/cart_create.c.gcov All code covered by tests in src/mpi/topo/cart_rank.c.gcov Uncovered lines in src/mpi/topo/dims_create.c.gcov 281: -: 230: "**argarrayneg", 282: -: 231: "**argarrayneg %s %d %d", "dims", i, dims[i]); 283: #####: 232: return mpi_errno; 523: branch 0 taken 0% (fallthrough) 524: branch 1 taken 100% 525: #####: 418: mpi_errno = MPIR_Process.dimsCreate( nnodes, ndims, dims ); 2 line(s) not covered by tests in src/mpi/topo/dims_create.c.gcov Uncovered lines in src/mpi/topo/graph_map.c.gcov 175: branch 2 never executed 176: branch 3 never executed 177: #####: 121: mpi_errno = comm_ptr->topo_fns->graphMap( comm_ptr, nnodes, 1 line(s) not covered by tests in src/mpi/topo/graph_map.c.gcov All code covered by tests in src/mpi/topo/graphdimsget.c.gcov All code covered by tests in src/mpi/topo/topo_test.c.gcov All code covered by tests in src/mpi/topo/mpiimpl.h.gcov All code covered by tests in src/mpi/topo/dist_gr_neighb.c.gcov All code covered by tests in src/util/info/infoutil.c.gcov All code covered by tests in src/util/info/info_create.c.gcov All code covered by tests in src/util/info/info_delete.c.gcov All code covered by tests in src/util/info/info_dup.c.gcov All code covered by tests in src/util/info/info_free.c.gcov All code covered by tests in src/util/info/info_get.c.gcov All code covered by tests in src/util/info/info_getn.c.gcov All code covered by tests in src/util/info/info_getnth.c.gcov All code covered by tests in src/util/info/info_getvallen.c.gcov All code covered by tests in src/util/info/info_set.c.gcov Uncovered lines in src/mpid/common/datatype/mpid_type_debug.c.gcov 499: branch 0 taken 100% (fallthrough) 500: branch 1 taken 0% 501: #####: 368: if (type == MPI_DOUBLE_PRECISION) return t_doubleprecision; 502: branch 0 never executed 503: branch 1 never executed 504: #####: 369: if (type == MPI_INTEGER) return t_integer; 505: branch 0 never executed 506: branch 1 never executed 507: #####: 370: if (type == MPI_2INTEGER) return t_2integer; 508: branch 0 never executed 509: branch 1 never executed 510: #####: 371: if (type == MPI_2COMPLEX) return t_2complex; 511: branch 0 never executed 512: branch 1 never executed 513: #####: 372: if (type == MPI_2DOUBLE_COMPLEX) return t_2doublecomplex; 514: branch 0 never executed 515: branch 1 never executed 516: #####: 373: if (type == MPI_2REAL) return t_2real; 517: branch 0 never executed 518: branch 1 never executed 519: #####: 374: if (type == MPI_2DOUBLE_PRECISION) return t_2doubleprecision; 520: branch 0 never executed 521: branch 1 never executed 522: #####: 375: if (type == MPI_CHARACTER) return t_character; 524: branch 1 never executed 525: -: 376: 526: #####: 377: return NULL; 579: branch 0 taken 100% (fallthrough) 580: branch 1 taken 0% 581: #####: 415: if (combiner == MPI_COMBINER_HVECTOR_INTEGER) return c_hvector_integer; 582: branch 0 never executed 583: branch 1 never executed 584: #####: 416: if (combiner == MPI_COMBINER_HINDEXED_INTEGER) return c_hindexed_integer; 585: branch 0 never executed 586: branch 1 never executed 587: #####: 417: if (combiner == MPI_COMBINER_INDEXED_BLOCK) return c_indexed_block; 588: branch 0 never executed 589: branch 1 never executed 590: #####: 418: if (combiner == MPI_COMBINER_STRUCT_INTEGER) return c_struct_integer; 591: branch 0 never executed 592: branch 1 never executed 593: #####: 419: if (combiner == MPI_COMBINER_SUBARRAY) return c_subarray; 594: branch 0 never executed 595: branch 1 never executed 596: #####: 420: if (combiner == MPI_COMBINER_DARRAY) return c_darray; 597: branch 0 never executed 598: branch 1 never executed 599: #####: 421: if (combiner == MPI_COMBINER_F90_REAL) return c_f90_real; 600: branch 0 never executed 601: branch 1 never executed 602: #####: 422: if (combiner == MPI_COMBINER_F90_COMPLEX) return c_f90_complex; 603: branch 0 never executed 604: branch 1 never executed 605: #####: 423: if (combiner == MPI_COMBINER_F90_INTEGER) return c_f90_integer; 606: branch 0 never executed 607: branch 1 never executed 608: #####: 424: if (combiner == MPI_COMBINER_RESIZED) return c_resized; 610: branch 1 never executed 611: -: 425: 612: #####: 426: return NULL; 20 line(s) not covered by tests in src/mpid/common/datatype/mpid_type_debug.c.gcov Uncovered lines in src/mpid/common/datatype/mpid_segment.c.gcov 190: -: 177: DLOOP_Offset *lengthp) 191: function MPID_Segment_flatten called 0 returned 0% blocks executed 0% 192: #####: 178:{ 196: -: 182:MPIDI_FUNC_ENTER(MPID_STATE_MPID_SEGMENT_FLATTEN); 197: -: 183: 198: #####: 184:packvec_params.u.flatten.offp = (int64_t *) offp; 199: #####: 185:packvec_params.u.flatten.sizep = sizep; 200: #####: 186:packvec_params.u.flatten.index = 0; 201: #####: 187:packvec_params.u.flatten.length = *lengthp; 202: -: 188: 203: #####: 189:MPIU_Assert(*lengthp > 0); 207: call 3 never executed 208: -: 190: 209: #####: 191:MPID_Segment_manipulate(segp, 219: -: 200: 220: -: 201:/* last value already handled by MPID_Segment_manipulate */ 221: #####: 202:*lengthp = packvec_params.u.flatten.index; 459: -: 410: void *v_paramp) 460: function MPID_Segment_contig_flatten called 0 returned 0% blocks executed 0% 461: #####: 411:{ 462: -: 412: int index, el_size; 463: -: 413: DLOOP_Offset size; 464: #####: 414: struct MPID_Segment_piece_params *paramp = v_paramp; 467: -: 417: MPIDI_FUNC_ENTER(MPID_STATE_MPID_SEGMENT_CONTIG_FLATTEN); 468: -: 418: 469: #####: 419: el_size = MPID_Datatype_get_basic_size(el_type); 470: #####: 420: size = *blocks_p * (DLOOP_Offset) el_size; 471: #####: 421: index = paramp->u.flatten.index; 480: -: 430:#endif 481: -: 431: 482: #####: 432: if (index > 0 && ((DLOOP_Offset) MPI_VOID_PTR_CAST_TO_MPI_AINT bufp + rel_off) == 489: -: 435: { 490: -: 436: /* add this size to the last vector rather than using up another one */ 491: #####: 437: paramp->u.flatten.sizep[index - 1] += size; 492: -: 438: } 493: -: 439: else { 494: #####: 440: paramp->u.flatten.offp[index] = ((int64_t) MPI_VOID_PTR_CAST_TO_MPI_AINT bufp) + (int64_t) rel_off; 495: #####: 441: paramp->u.flatten.sizep[index] = size; 496: -: 442: 497: #####: 443: paramp->u.flatten.index++; 499: -: 445: * return 1 to stop processing 500: -: 446: */ 501: #####: 447: if (paramp->u.flatten.index == paramp->u.flatten.length) 504: branch 1 never executed 505: -: 448: { 506: #####: 450: return 1; 508: -: 451: } 509: -: 452: } 510: #####: 454: return 0; 534: -: 478: void *v_paramp) 535: function MPID_Segment_vector_flatten called 0 returned 0% blocks executed 0% 536: #####: 479:{ 537: -: 480: int i; 538: -: 481: DLOOP_Offset size, blocks_left, basic_size; 539: #####: 482: struct MPID_Segment_piece_params *paramp = v_paramp; 542: -: 485: MPIDI_FUNC_ENTER(MPID_STATE_MPID_SEGMENT_VECTOR_FLATTEN); 543: -: 486: 544: #####: 487: basic_size = (DLOOP_Offset) MPID_Datatype_get_basic_size(el_type); 545: #####: 488: blocks_left = *blocks_p; 546: -: 489: 547: #####: 490: for (i=0; i < count && blocks_left > 0; i++) { 548: branch 0 never executed 549: branch 1 never executed 550: #####: 491: int index = paramp->u.flatten.index; 551: -: 492: 552: #####: 493: if (blocks_left > (DLOOP_Offset) blksz) { 553: branch 0 never executed 554: branch 1 never executed 555: #####: 494: size = ((DLOOP_Offset) blksz) * basic_size; 556: #####: 495: blocks_left -= (DLOOP_Offset) blksz; 558: -: 497: else { 559: -: 498: /* last pass */ 560: #####: 499: size = blocks_left * basic_size; 561: #####: 500: blocks_left = 0; 562: -: 501: } 563: -: 502: 564: #####: 503: if (index > 0 && ((DLOOP_Offset) MPI_VOID_PTR_CAST_TO_MPI_AINT bufp + rel_off) == 570: -: 505: { 571: -: 506: /* add this size to the last region rather than using up another one */ 572: #####: 507: paramp->u.flatten.sizep[index - 1] += size; 573: -: 508: } 574: #####: 509: else if (index < paramp->u.flatten.length) { 576: branch 1 never executed 577: -: 510: /* take up another region */ 578: #####: 511: paramp->u.flatten.offp[index] = (DLOOP_Offset) MPI_VOID_PTR_CAST_TO_MPI_AINT bufp + rel_off; 579: #####: 512: paramp->u.flatten.sizep[index] = size; 580: #####: 513: paramp->u.flatten.index++; 582: -: 515: else { 583: -: 516: /* we tried to add to the end of the last region and failed; add blocks back in */ 584: #####: 517: *blocks_p = *blocks_p - blocks_left + (size / basic_size); 585: #####: 517: *blocks_p = *blocks_p - blocks_left + (size / basic_size); 586: #####: 519: return 1; 587: -: 520: } 588: #####: 521: rel_off += stride; 597: -: 522: 598: -: 523: } 599: #####: 528: return 0; 42 line(s) not covered by tests in src/mpid/common/datatype/mpid_segment.c.gcov Uncovered lines in src/mpid/common/datatype/mpid_ext32_segment.c.gcov 99: branch 1 taken 100% 100: -: 79: { 101: #####: 80: while(src_ptr != src_end) 103: branch 1 never executed 104: -: 81: { 105: #####: 82: BASIC_convert16((*(TWO_BYTE_BASIC_TYPE *)src_ptr), 106: -: 83: (*(TWO_BYTE_BASIC_TYPE *)dest_ptr)); 107: -: 84: 108: #####: 85: src_ptr += src_el_size; 109: #####: 86: dest_ptr += dest_el_size; 125: -: 98: } 126: -: 99: } 127: #####: 100: else if (src_el_size == 8) 129: branch 1 never executed 130: -: 101: { 131: #####: 102: while(src_ptr != src_end) 133: branch 1 never executed 134: -: 103: { 135: #####: 104: BASIC_convert64(src_ptr, dest_ptr); 136: call 0 never executed 137: -: 105: 138: #####: 106: src_ptr += src_el_size; 139: #####: 107: dest_ptr += dest_el_size; 172: branch 1 taken 100% 173: -: 132: { 174: #####: 133: while(src_ptr != src_end) 176: branch 1 never executed 177: -: 134: { 178: #####: 135: FLOAT_convert((*(FOUR_BYTE_FLOAT_TYPE *)src_ptr), 187: -: 136: (*(FOUR_BYTE_FLOAT_TYPE *)dest_ptr)); 188: -: 137: 189: #####: 138: src_ptr += src_el_size; 190: #####: 139: dest_ptr += dest_el_size; 13 line(s) not covered by tests in src/mpid/common/datatype/mpid_ext32_segment.c.gcov All code covered by tests in src/mpid/common/datatype/mpid_ext32_segment.h.gcov All code covered by tests in src/mpid/common/datatype/mpiimpl.h.gcov Uncovered lines in src/mpid/common/datatype/mpid_ext32_datatype.c.gcov 105: -: 91: } 106: -: 92: else { 107: #####: 93: MPID_Dataloop *dlp = NULL; 108: -: 94: 109: #####: 95: MPID_Datatype_get_loopptr_macro(type, dlp, MPID_DATALOOP_HETEROGENEOUS); 113: call 3 never executed 114: -: 96: 115: #####: 97: return MPID_Dataloop_stream_size(dlp, 3 line(s) not covered by tests in src/mpid/common/datatype/mpid_ext32_datatype.c.gcov All code covered by tests in src/mpid/common/datatype/mpid_type_dup.c.gcov Uncovered lines in src/mpid/common/datatype/mpir_type_get_contig_blocks.c.gcov 32: -: 27: int *nr_blocks_p) 33: function MPIR_Type_get_contig_blocks called 0 returned 0% blocks executed 0% 34: #####: 28:{ 35: -: 29: MPID_Datatype *datatype_ptr; 36: -: 30: 37: #####: 31: if (HANDLE_GET_KIND(type) == HANDLE_KIND_BUILTIN) { 38: branch 0 never executed 39: branch 1 never executed 40: #####: 32: *nr_blocks_p = 1; 41: #####: 33: return 0; 42: -: 34: } 43: -: 35: 44: #####: 36: MPID_Datatype_get_ptr(type, datatype_ptr); 48: branch 3 never executed 49: call 4 never executed 50: #####: 37: MPIU_Assert(datatype_ptr->is_committed); 54: call 3 never executed 55: -: 38: 56: #####: 39: *nr_blocks_p = datatype_ptr->max_contig_blocks; 57: #####: 40: return 0; 8 line(s) not covered by tests in src/mpid/common/datatype/mpir_type_get_contig_blocks.c.gcov Uncovered lines in src/mpid/common/datatype/mpir_type_flatten.c.gcov 34: -: 29: MPI_Aint *array_len_p) 35: function MPIR_Type_flatten called 0 returned 0% blocks executed 0% 36: #####: 30:{ 39: -: 33: MPID_Segment *segp; 40: -: 34: 41: #####: 35: if (HANDLE_GET_KIND(type) == HANDLE_KIND_BUILTIN) { 42: branch 0 never executed 43: branch 1 never executed 44: #####: 36: off_array[0] = 0; 45: #####: 37: MPID_Datatype_get_size_macro(type, size_array[0]); 49: branch 3 never executed 50: call 4 never executed 51: #####: 38: *array_len_p = 1; 52: #####: 39: return 0; 53: -: 40: } 54: -: 41: 55: #####: 42: MPID_Datatype_get_ptr(type, datatype_ptr); 59: branch 3 never executed 60: call 4 never executed 61: #####: 43: MPIU_Assert(datatype_ptr->is_committed); 64: call 2 never executed 65: call 3 never executed 66: #####: 44: MPIU_Assert(*array_len_p >= datatype_ptr->max_contig_blocks); 70: call 3 never executed 71: -: 45: 72: #####: 46: segp = MPID_Segment_alloc(); 73: call 0 never executed 74: #####: 47: MPID_Segment_init(0, 1, type, segp, 0); /* first 0 is bufptr, 78: -: 50: */ 79: -: 51: 80: #####: 52: first = 0; 81: #####: 53: last = SEGMENT_IGNORE_LAST; 82: -: 54: 83: #####: 55: MPID_Segment_flatten(segp, 89: -: 60: array_len_p); 90: -: 61: 91: #####: 62: MPID_Segment_free(segp); 92: call 0 never executed 93: -: 63: 94: #####: 64: return 0; 16 line(s) not covered by tests in src/mpid/common/datatype/mpir_type_flatten.c.gcov All code covered by tests in src/mpid/common/datatype/mpid_type_commit.c.gcov All code covered by tests in src/mpid/common/datatype/mpid_type_zerolen.c.gcov All code covered by tests in src/mpid/common/datatype/mpid_type_contiguous.c.gcov All code covered by tests in src/mpid/common/datatype/mpid_type_create_resized.c.gcov All code covered by tests in src/mpid/common/datatype/mpid_type_indexed.c.gcov All code covered by tests in src/mpid/common/datatype/mpid_type_get_envelope.c.gcov All code covered by tests in src/mpid/common/datatype/mpid_datatype_free.c.gcov All code covered by tests in src/mpid/common/datatype/mpid_type_get_contents.c.gcov Uncovered lines in src/mpid/common/datatype/mpid_contents_support.c.gcov 68: branch 0 taken 0% (fallthrough) 69: branch 1 taken 100% 70: #####: 42: struct_sz += align_sz - epsilon; 73: branch 0 taken 0% (fallthrough) 74: branch 1 taken 100% 75: #####: 45: types_sz += align_sz - epsilon; 78: branch 0 taken 0% (fallthrough) 79: branch 1 taken 100% 80: #####: 48: ints_sz += align_sz - epsilon; 3 line(s) not covered by tests in src/mpid/common/datatype/mpid_contents_support.c.gcov All code covered by tests in src/mpid/common/datatype/mpid_type_vector.c.gcov All code covered by tests in src/mpid/common/datatype/mpid_type_blockindexed.c.gcov Uncovered lines in src/mpid/common/datatype/mpid_type_struct.c.gcov 247: branch 1 taken 100% 248: -: 207: { 249: #####: 208: MPIU_Handle_obj_free(&MPID_Datatype_mem, new_dtp); 250: call 0 never executed 251: #####: 209: return MPID_Type_zerolen(newtype); 2 line(s) not covered by tests in src/mpid/common/datatype/mpid_type_struct.c.gcov Uncovered lines in src/mpid/common/datatype/mpid_datatype_contents.c.gcov 59: branch 0 taken 0% (fallthrough) 60: branch 1 taken 100% 61: #####: 51: struct_sz += align_sz - epsilon; 64: branch 0 taken 0% (fallthrough) 65: branch 1 taken 100% 66: #####: 54: types_sz += align_sz - epsilon; 69: branch 0 taken 0% (fallthrough) 70: branch 1 taken 100% 71: #####: 57: ints_sz += align_sz - epsilon; 233: branch 0 taken 0% (fallthrough) 234: branch 1 taken 100% 235: #####: 120: struct_sz += align_sz - epsilon; 301: branch 0 taken 0% (fallthrough) 302: branch 1 taken 100% 303: #####: 159: struct_sz += align_sz - epsilon; 306: branch 0 taken 0% (fallthrough) 307: branch 1 taken 100% 308: #####: 162: types_sz += align_sz - epsilon; 370: branch 0 taken 0% (fallthrough) 371: branch 1 taken 100% 372: #####: 196: struct_sz += align_sz - epsilon; 375: branch 0 taken 0% (fallthrough) 376: branch 1 taken 100% 377: #####: 199: types_sz += align_sz - epsilon; 380: branch 0 taken 0% (fallthrough) 381: branch 1 taken 100% 382: #####: 202: ints_sz += align_sz - epsilon; 440: branch 0 taken 0% (fallthrough) 441: branch 1 taken 100% 442: #####: 232: struct_sz += align_sz - epsilon; 10 line(s) not covered by tests in src/mpid/common/datatype/mpid_datatype_contents.c.gcov All code covered by tests in src/mpid/common/datatype/mpid_type_create_pairtype.c.gcov All code covered by tests in src/mpid/common/datatype/dataloop/mpiimpl.h.gcov Uncovered lines in src/mpid/common/datatype/dataloop/segment.c.gcov 115: branch 1 taken 100% 116: -: 88: /* only use the builtin */ 117: #####: 89: sblp->kind = DLOOP_KIND_CONTIG | DLOOP_FINAL_MASK; 118: #####: 90: sblp->loop_params.c_t.count = 0; 119: #####: 91: sblp->loop_params.c_t.dataloop = 0; 120: #####: 92: sblp->el_size = 0; 121: #####: 93: sblp->el_extent = 0; 122: -: 94: 123: #####: 95: dlp = sblp; 124: #####: 96: depth = 1; 285: 27992: 190: break; 286: -: 191: case DLOOP_KIND_STRUCT: 287: #####: 192: dlp = dlp->loop_params.s_t.dataloop_array[0]; 288: #####: 193: break; 473: branch 1 taken 100% 474: -: 369: /* nothing to do */ 475: #####: 370: DLOOP_dbg_printf("dloop_segment_manipulate: warning: first == last (" MPI_AINT_FMT_DEC_SPEC ")\n", first); 476: call 0 never executed 477: #####: 371: return; 499: branch 0 taken 0% (fallthrough) 500: branch 1 taken 100% 501: #####: 387: DLOOP_Offset tmp_last = first; 504: -: 390: * stream offset 505: -: 391: */ 506: #####: 392: PREPEND_PREFIX(Segment_manipulate)(segp, 685: branch 5 taken 0% 686: -: 519: case PF_NULL: 687: #####: 520: piecefn_indicated_exit = 0; 689: -: 522: DLOOP_dbg_printf("\tNULL piecefn for this piece\n"); 690: -: 523:#endif 691: #####: 524: break; 961: 34: 711: break; 962: -: 712: case DLOOP_KIND_STRUCT: 963: #####: 713: cur_elmp->orig_block = 965: branch 1 never executed 966: -: 714: DLOOP_STACKELM_STRUCT_BLOCKSIZE(cur_elmp, cur_elmp->curcount ? cur_elmp->orig_count - cur_elmp->curcount : 0); 967: #####: 715: break; 1000: branch 0 taken 0% (fallthrough) 1001: branch 1 taken 100% 1002: #####: 742: DLOOP_Dataloop *load_dlp = NULL; 1003: #####: 743: switch (cur_elmp->loop_p->kind & DLOOP_KIND_MASK) { 1009: -: 746: case DLOOP_KIND_BLOCKINDEXED: 1010: -: 747: case DLOOP_KIND_INDEXED: 1011: #####: 748: load_dlp = cur_elmp->loop_p->loop_params.cm_t.dataloop; 1012: #####: 749: break; 1013: -: 750: case DLOOP_KIND_STRUCT: 1014: #####: 751: load_dlp = DLOOP_STACKELM_STRUCT_DATALOOP(cur_elmp, 1015: -: 752: count_index); 1016: #####: 753: break; 1031: -: 766:#endif 1032: -: 767: 1033: #####: 768: DLOOP_Stackelm_load(next_elmp, 1075: 171: 803: break; 1076: -: 804: case DLOOP_KIND_STRUCT: 1077: #####: 805: next_elmp->orig_offset = cur_elmp->orig_offset + 1078: -: 806: (DLOOP_Offset) block_index * DLOOP_STACKELM_STRUCT_EL_EXTENT(cur_elmp, count_index) + 1079: -: 807: DLOOP_STACKELM_STRUCT_OFFSET(cur_elmp, count_index); 1080: #####: 808: break; 1120: 4694682: 841: break; 1121: -: 842: case DLOOP_KIND_STRUCT: 1122: #####: 843: next_elmp->curcount = next_elmp->orig_count; 1123: #####: 844: next_elmp->curblock = 1124: -: 845: DLOOP_STACKELM_STRUCT_BLOCKSIZE(next_elmp, 0); 1125: #####: 846: next_elmp->curoffset = next_elmp->orig_offset + 1126: -: 847: DLOOP_STACKELM_STRUCT_OFFSET(next_elmp, 0); 1127: #####: 848: break; 1190: -: 902: break; 1191: -: 903: case DLOOP_KIND_STRUCT: 1192: #####: 904: return dlp->loop_params.s_t.blocksize_array[elmp->orig_count - elmp->curcount]; 1200: -: 906: default: 1201: -: 911: } 1202: #####: 912: return -1; 1235: -: 939: break; 1236: -: 940: case DLOOP_KIND_STRUCT: 1237: #####: 941: return dlp->loop_params.s_t.offset_array[elmp->orig_count - elmp->curcount]; 1245: -: 943: default: 1246: -: 948: } 1247: #####: 949: return -1; 1274: branch 3 taken 100% 1275: -: 970: { 1276: #####: 971: elmp->may_require_reloading = 1; 35 line(s) not covered by tests in src/mpid/common/datatype/dataloop/segment.c.gcov Uncovered lines in src/mpid/common/datatype/dataloop/dataloop_create.c.gcov 52: branch 0 taken 0% (fallthrough) 53: branch 1 taken 100% 54: #####: 45: DLOOP_Dataloop_create_named(type, dlp_p, dlsz_p, dldepth_p, flag); 55: call 0 never executed 56: #####: 46: return; 74: branch 1 taken 100% 75: -: 55: /* dataloop already created; just return it. */ 76: #####: 56: *dlp_p = old_dlp; 77: #####: 57: DLOOP_Handle_get_loopsize_macro(type, *dlsz_p, flag); 84: branch 6 never executed 85: branch 7 never executed 86: #####: 58: DLOOP_Handle_get_loopdepth_macro(type, *dldepth_p, flag); 290: branch 0 taken 0% (fallthrough) 291: branch 1 taken 100% 292: #####: 172: stride = (MPI_Aint) ints[2]; 331: branch 0 taken 0% (fallthrough) 332: branch 1 taken 100% 333: #####: 208: disps = (MPI_Aint *) DLOOP_Malloc(ints[0] * sizeof(MPI_Aint)); 334: call 0 never executed 335: -: 209: 336: #####: 210: for (i=0; i < ints[0]; i++) { 337: branch 0 never executed 338: branch 1 never executed 339: #####: 211: disps[i] = (MPI_Aint) ints[ints[0] + 1 + i]; 356: branch 0 taken 0% (fallthrough) 357: branch 1 taken 100% 358: #####: 227: DLOOP_Free(disps); 430: branch 0 taken 0% (fallthrough) 431: branch 1 taken 100% 432: #####: 258: disps = (MPI_Aint *) DLOOP_Malloc(ints[0] * sizeof(MPI_Aint)); 433: call 0 never executed 434: -: 259: 435: #####: 260: for (i=0; i < ints[0]; i++) { 436: branch 0 never executed 437: branch 1 never executed 438: #####: 261: disps[i] = (MPI_Aint) ints[ints[0] + 1 + i]; 454: branch 0 taken 0% (fallthrough) 455: branch 1 taken 100% 456: #####: 276: DLOOP_Free(disps); 508: -: 321: /* TODO: WHAT DO I DO HERE? */ 509: -: 322: default: 510: #####: 323: DLOOP_Assert(0); 541: -: 351: int flag) 542: function DLOOP_Dataloop_create_named called 0 returned 0% blocks executed 0% 543: #####: 352:{ 553: -: 362: * case. 554: -: 363: */ 555: #####: 364: if (type == MPI_FLOAT_INT || type == MPI_DOUBLE_INT || 561: -: 366: type == MPI_LONG_DOUBLE_INT) 562: -: 367: { 563: #####: 368: DLOOP_Handle_get_loopptr_macro(type, dlp, flag); 570: branch 6 never executed 571: branch 7 never executed 572: #####: 369: if (dlp != NULL) { 574: branch 1 never executed 575: -: 370: /* dataloop already created; just return it. */ 576: #####: 371: *dlp_p = dlp; 577: #####: 372: DLOOP_Handle_get_loopsize_macro(type, *dlsz_p, flag); 584: branch 6 never executed 585: branch 7 never executed 586: #####: 373: DLOOP_Handle_get_loopdepth_macro(type, *dldepth_p, flag); 595: -: 374: } 596: -: 375: else { 597: #####: 376: PREPEND_PREFIX(Dataloop_create_pairtype)(type, 606: -: 384: /* no other combiners need dataloops; exit. */ 607: -: 385: else { 608: #####: 386: *dlp_p = NULL; 609: #####: 387: *dlsz_p = 0; 610: #####: 388: *dldepth_p = 0; 611: #####: 389: return; 27 line(s) not covered by tests in src/mpid/common/datatype/dataloop/dataloop_create.c.gcov Uncovered lines in src/mpid/common/datatype/dataloop/dataloop_create_vector.c.gcov 60: -: 52: { 61: -: 53: 62: #####: 54: err = PREPEND_PREFIX(Dataloop_create_contiguous)(0, 67: -: 58: dldepth_p, 68: -: 59: flag); 69: #####: 60: return err; 152: -: 110: { 153: -: 111: 154: #####: 112: blocklength *= basic_sz; 155: #####: 113: new_dlp->el_size = 1; 156: #####: 114: new_dlp->el_extent = 1; 157: #####: 115: new_dlp->el_type = MPI_BYTE; 158: -: 116: 159: #####: 117: if(!strideinbytes) 163: -: 119: that we're using bytes, rather than oldtype, we 164: -: 120: need to update stride. */ 165: #####: 121: stride *= basic_sz; 8 line(s) not covered by tests in src/mpid/common/datatype/dataloop/dataloop_create_vector.c.gcov Uncovered lines in src/mpid/common/datatype/dataloop/dataloop_create_blockindexed.c.gcov 63: branch 1 taken 100% 64: -: 56: { 65: #####: 57: err = PREPEND_PREFIX(Dataloop_create_contiguous)(0, 70: -: 61: dldepth_p, 71: -: 62: flag); 72: #####: 63: return err; 245: branch 1 taken 100% 246: -: 188: { 247: #####: 189: blklen *= old_extent; 248: #####: 190: new_dlp->el_size = 1; 249: #####: 191: new_dlp->el_extent = 1; 250: #####: 192: new_dlp->el_type = MPI_BYTE; 6 line(s) not covered by tests in src/mpid/common/datatype/dataloop/dataloop_create_blockindexed.c.gcov Uncovered lines in src/mpid/common/datatype/dataloop/dataloop_create_struct.c.gcov 96: branch 1 taken 100% 97: -: 89: { 98: #####: 90: err = PREPEND_PREFIX(Dataloop_create_contiguous)(0, 103: -: 94: dldepth_p, 104: -: 95: flag); 105: #####: 96: return err; 180: branch 1 taken 100% 181: -: 154: { 182: #####: 155: err = PREPEND_PREFIX(Dataloop_create_contiguous)(0, 187: -: 159: dldepth_p, 188: -: 160: flag); 189: #####: 161: return err; 4 line(s) not covered by tests in src/mpid/common/datatype/dataloop/dataloop_create_struct.c.gcov All code covered by tests in src/mpid/common/datatype/dataloop/subarray_support.c.gcov Uncovered lines in src/mpid/common/datatype/dataloop/darray_support.c.gcov 66: branch 1 taken 100% 67: -: 54: /* dimension 0 changes fastest */ 68: #####: 55: for (i=0; idim; i--) stride *= (MPI_Aint)(array_of_gsizes[i]); 338: branch 1 never executed 339: -: 254: 340: #####: 255: NMPI_Type_hvector(count, blksize, stride, type_old, type_new); 341: call 0 never executed 342: -: 256: 343: #####: 257: if (rem) { 347: -: 259: it separately using MPI_Type_struct */ 348: -: 260: 349: #####: 261: types[0] = *type_new; 350: #####: 262: types[1] = type_old; 351: #####: 263: disps[0] = 0; 352: #####: 264: disps[1] = ((MPI_Aint) count) * stride; 353: #####: 265: blklens[0] = 1; 354: #####: 266: blklens[1] = rem; 355: -: 267: 356: #####: 268: NMPI_Type_struct(2, blklens, disps, types, &type_tmp); 357: call 0 never executed 358: -: 269: 359: #####: 270: NMPI_Type_free(type_new); 360: call 0 never executed 361: #####: 271: *type_new = type_tmp; 364: -: 274: /* In the first iteration, we need to set the displacement in that 365: -: 275: dimension correctly. */ 366: #####: 276: if (((order == MPI_ORDER_FORTRAN) && (dim == 0)) || 372: branch 5 never executed 373: -: 277: ((order == MPI_ORDER_C) && (dim == ndims-1))) { 374: #####: 278: types[0] = MPI_LB; 375: #####: 279: disps[0] = 0; 376: #####: 280: types[1] = *type_new; 377: #####: 281: disps[1] = ((MPI_Aint) rank) * ((MPI_Aint) blksize) * orig_extent; 378: #####: 282: types[2] = MPI_UB; 379: #####: 283: disps[2] = orig_extent * ((MPI_Aint)(array_of_gsizes[dim])); 380: #####: 284: blklens[0] = blklens[1] = blklens[2] = 1; 381: #####: 285: NMPI_Type_struct(3, blklens, disps, types, &type_tmp); 382: call 0 never executed 383: #####: 286: NMPI_Type_free(type_new); 384: call 0 never executed 385: #####: 287: *type_new = type_tmp; 386: -: 288: 387: #####: 289: *st_offset = 0; /* set it to 0 because it is taken care of in 389: -: 291: } 390: -: 292: else { 391: #####: 293: *st_offset = ((MPI_Aint) rank) * ((MPI_Aint) blksize); 394: -: 296: } 395: -: 297: 396: #####: 298: if (local_size == 0) *st_offset = 0; 398: branch 1 never executed 399: -: 299: 400: #####: 300: return MPI_SUCCESS; 62 line(s) not covered by tests in src/mpid/common/datatype/dataloop/darray_support.c.gcov Uncovered lines in src/mpid/common/datatype/dataloop/dataloop.c.gcov 269: -: 208: { 270: -: 209: MPID_Ensure_Aint_fits_in_pointer(MPI_VOID_PTR_CAST_TO_MPI_AINT (char *) dataloop->loop_params.i_t.dataloop + ptrdiff); 271: #####: 210: dataloop->loop_params.i_t.dataloop = 277: branch 0 taken 0% (fallthrough) 278: branch 1 taken 100% 279: #####: 216: PREPEND_PREFIX(Dataloop_update)(dataloop->loop_params.i_t.dataloop, ptrdiff); 440: -: 343: case DLOOP_KIND_STRUCT: 441: -: 344: /* need space for dataloop pointers and extents */ 442: #####: 345: ptr_sz = count * sizeof(DLOOP_Dataloop *); 443: #####: 346: extent_sz = count * sizeof(DLOOP_Offset); 452: -: 355: break; 453: -: 356: default: 454: #####: 357: DLOOP_Assert(0); 492: branch 0 taken 0% (fallthrough) 493: branch 1 taken 100% 494: #####: 382: *new_loop_p = NULL; 495: #####: 383: return; 523: -: 405: * - extents 524: -: 406: */ 525: #####: 407: new_loop->loop_params.s_t.dataloop_array = 526: -: 408: (DLOOP_Dataloop **) (((char *) new_loop) + loop_sz); 527: #####: 409: new_loop->loop_params.s_t.blocksize_array = 528: -: 410: (DLOOP_Count *) (((char *) new_loop) + loop_sz + ptr_sz); 529: #####: 411: new_loop->loop_params.s_t.offset_array = 530: -: 412: (DLOOP_Offset *) (((char *) new_loop) + loop_sz + 531: -: 413: ptr_sz + blk_sz); 532: #####: 414: new_loop->loop_params.s_t.el_extent_array = 533: -: 415: (DLOOP_Offset *) (((char *) new_loop) + loop_sz + 534: -: 416: ptr_sz + blk_sz + off_sz); 535: #####: 417: break; 593: -: 467: break; 594: -: 468: default: 595: #####: 469: DLOOP_Assert(0); 710: branch 0 taken 0% (fallthrough) 711: branch 1 taken 100% 712: #####: 563: *new_loop_p = NULL; 713: #####: 564: return; 773: branch 0 taken 0% (fallthrough) 774: branch 1 taken 100% 775: #####: 614: *new_loop_p = NULL; 776: #####: 615: return; 796: -: 634: DLOOP_Offset (*sizefn)(DLOOP_Type el_type)) 797: function MPID_Dataloop_stream_size called 0 returned 0% blocks executed 0% 798: #####: 635:{ 799: #####: 636: DLOOP_Offset tmp_sz, tmp_ct = 1; 801: -: 638: for (;;) 802: -: 639: { 803: #####: 640: if ((dl_p->kind & DLOOP_KIND_MASK) == DLOOP_KIND_STRUCT) 807: -: 642: int i; 808: -: 643: 809: #####: 644: tmp_sz = 0; 810: #####: 645: for (i = 0; i < dl_p->loop_params.s_t.count; i++) 812: branch 1 never executed 813: -: 646: { 814: #####: 647: tmp_sz += (DLOOP_Offset)(dl_p->loop_params.s_t.blocksize_array[i]) * 816: -: 648: PREPEND_PREFIX(Dataloop_stream_size)(dl_p->loop_params.s_t.dataloop_array[i], sizefn); 817: -: 649: } 818: #####: 650: return tmp_sz * tmp_ct; 819: -: 651: } 820: -: 652: 821: #####: 653: switch (dl_p->kind & DLOOP_KIND_MASK) { 826: branch 4 never executed 827: -: 654: case DLOOP_KIND_CONTIG: 828: #####: 655: tmp_ct *= (DLOOP_Offset)(dl_p->loop_params.c_t.count); 831: -: 658: (int) dl_p->loop_params.c_t.count, (MPI_Aint) tmp_ct); 832: -: 659:#endif 833: #####: 660: break; 834: -: 661: case DLOOP_KIND_VECTOR: 835: #####: 662: tmp_ct *= (DLOOP_Offset)(dl_p->loop_params.v_t.count) * 841: -: 668: (MPI_Aint) tmp_ct); 842: -: 669:#endif 843: #####: 670: break; 844: -: 671: case DLOOP_KIND_BLOCKINDEXED: 845: #####: 672: tmp_ct *= (DLOOP_Offset)(dl_p->loop_params.bi_t.count) * 851: -: 678: (MPI_Aint) tmp_ct); 852: -: 679:#endif 853: #####: 680: break; 854: -: 681: case DLOOP_KIND_INDEXED: 855: #####: 682: tmp_ct *= (DLOOP_Offset)(dl_p->loop_params.i_t.total_blocks); 859: -: 686: (MPI_Aint) tmp_ct); 860: -: 687:#endif 861: #####: 688: break; 869: -: 694: } 870: -: 695: 871: #####: 696: if (dl_p->kind & DLOOP_FINAL_MASK) break; 873: branch 1 never executed 874: -: 697: else { 875: #####: 698: DLOOP_Assert(dl_p->loop_params.cm_t.dataloop != NULL); 878: call 2 never executed 879: call 3 never executed 880: #####: 699: dl_p = dl_p->loop_params.cm_t.dataloop; 883: -: 702: 884: -: 703: /* call fn for size using bottom type, or use size if fnptr is NULL */ 885: #####: 704: tmp_sz = ((sizefn) ? sizefn(dl_p->el_type) : dl_p->el_size); 888: call 2 never executed 889: -: 705: 890: #####: 706: return tmp_sz * tmp_ct; 38 line(s) not covered by tests in src/mpid/common/datatype/dataloop/dataloop.c.gcov Uncovered lines in src/mpid/common/datatype/dataloop/segment_ops.c.gcov 596: branch 0 taken 0% (fallthrough) 597: branch 1 taken 100% 598: #####: 124: DLOOP_Memcpy(cbufp, paramp->streambuf, ((DLOOP_Offset) blocks_left) * el_size); 627: -: 128: MPID_Ensure_Aint_fits_in_pointer((MPI_VOID_PTR_CAST_TO_MPI_AINT (paramp->streambuf)) + 628: -: 129: ((DLOOP_Offset) blocks_left) * el_size); 629: #####: 130: paramp->streambuf += ((DLOOP_Offset) blocks_left) * el_size; 1065: branch 0 taken 0% (fallthrough) 1066: branch 1 taken 100% 1067: #####: 169: DLOOP_Memcpy(paramp->streambuf, cbufp, (DLOOP_Offset) blocks_left * el_size); 1096: -: 173: MPID_Ensure_Aint_fits_in_pointer((MPI_VOID_PTR_CAST_TO_MPI_AINT (paramp->streambuf)) + 1097: -: 174: (DLOOP_Offset) blocks_left * el_size); 1098: #####: 175: paramp->streambuf += (DLOOP_Offset) blocks_left * el_size; 1170: -: 227: MPIR_ALIGN8_TEST(src, dest)) 1171: -: 228: { 1172: #####: 229: MPIDI_COPY_FROM_VEC(src, dest, 0, int64_t, blocklen, 1); 1264: branch 0 taken 0% (fallthrough) 1265: branch 1 taken 100% 1266: #####: 237: MPIDI_COPY_FROM_VEC(src, dest, 0, int16_t, blocklen, 1); 1415: -: 301: MPIR_ALIGN8_TEST(src, dest)) 1416: -: 302: { 1417: #####: 303: MPIDI_COPY_FROM_VEC(src, dest, 0, int64_t, cur_block_sz, 1); 1509: branch 0 taken 0% (fallthrough) 1510: branch 1 taken 100% 1511: #####: 311: MPIDI_COPY_FROM_VEC(src, dest, 0, int16_t, cur_block_sz, 1); 1695: -: 412: { 1696: -: 413: /* this region is adjacent to the last */ 1697: #####: 414: paramp->last_loc += size; 1761: -: 460: { 1762: -: 461: /* first block sits at end of last block */ 1763: #####: 462: new_blk_count--; 1783: -: 482: void *v_paramp) 1784: function DLOOP_Segment_blkidx_count_block called 0 returned 0% blocks executed 0% 1785: #####: 483:{ 1786: -: 484: DLOOP_Count i, new_blk_count; 1787: -: 485: DLOOP_Offset size, el_size, last_loc; 1788: #####: 486: struct PREPEND_PREFIX(contig_blocks_params) *paramp = v_paramp; 1789: -: 487: 1790: #####: 488: DLOOP_Assert(count > 0 && blksz > 0 && *blocks_p > 0); 1796: call 5 never executed 1797: -: 489: 1798: #####: 490: DLOOP_Handle_get_size_macro(el_type, el_size); 1802: branch 3 never executed 1803: call 4 never executed 1804: #####: 491: size = el_size * (DLOOP_Offset) blksz; 1805: #####: 492: new_blk_count = count; 1806: -: 493: 1807: #####: 494: if (paramp->count > 0 && ((rel_off + offsetarray[0]) == paramp->last_loc)) 1812: -: 495: { 1813: -: 496: /* first block sits at end of last block */ 1814: #####: 497: new_blk_count--; 1815: -: 498: } 1816: -: 499: 1817: #####: 500: last_loc = rel_off + offsetarray[0] + size; 1818: #####: 501: for (i=1; i < count; i++) { 1819: branch 0 never executed 1820: branch 1 never executed 1821: #####: 502: if (last_loc == rel_off + offsetarray[i]) new_blk_count--; 1823: branch 1 never executed 1824: -: 503: 1825: #####: 504: last_loc = rel_off + offsetarray[i] + size; 1826: -: 505: } 1827: -: 506: 1828: #####: 507: paramp->last_loc = last_loc; 1829: #####: 508: paramp->count += new_blk_count; 1830: #####: 509: return 0; 1985: -: 638: * sizeof a pointer is less than the sizeof an MPI_Aint. 1986: -: 639: */ 1987: #####: 640: last_end = (char*) MPI_AINT_CAST_TO_VOID_PTR 2004: -: 653: * function that we are done (and that we didn't process any blocks). 2005: -: 654: */ 2006: #####: 655: *blocks_p = 0; 2007: #####: 656: return 1; 2014: -: 659: { 2015: -: 660: /* add this size to the last vector rather than using up another one */ 2016: #####: 661: paramp->blklens[last_idx] += size; 2114: -: 743: * the end of the last one. 2115: -: 744: */ 2116: #####: 745: *blocks_p -= (blocks_left + (size / (int) el_size)); 2120: -: 749: *blocks_p); 2121: -: 750:#endif 2122: #####: 751: return 1; 2129: -: 754: { 2130: -: 755: /* add this size to the last vector rather than using up new one */ 2131: #####: 756: paramp->blklens[last_idx] += size; 2171: -: 792: void *v_paramp) 2172: function DLOOP_Segment_blkidx_mpi_flatten called 0 returned 0% blocks executed 0% 2173: #####: 793:{ 2174: -: 794: int i, size, blocks_left; 2175: -: 795: DLOOP_Offset el_size; 2176: #####: 796: struct PREPEND_PREFIX(mpi_flatten_params) *paramp = v_paramp; 2177: -: 797: 2178: #####: 798: DLOOP_Handle_get_size_macro(el_type, el_size); 2182: branch 3 never executed 2183: call 4 never executed 2184: #####: 799: blocks_left = *blocks_p; 2185: -: 800: 2186: #####: 801: for (i=0; i < count && blocks_left > 0; i++) { 2188: branch 1 never executed 2189: -: 802: int last_idx; 2190: #####: 803: char *last_end = NULL; 2191: -: 804: 2192: #####: 805: if (blocks_left > blksz) { 2193: branch 0 never executed 2194: branch 1 never executed 2195: #####: 806: size = blksz * (int) el_size; 2196: #####: 807: blocks_left -= blksz; 2198: -: 809: else { 2199: -: 810: /* last pass */ 2200: #####: 811: size = blocks_left * (int) el_size; 2201: #####: 812: blocks_left = 0; 2202: -: 813: } 2203: -: 814: 2204: #####: 815: last_idx = paramp->index - 1; 2205: #####: 816: if (last_idx >= 0) { 2213: -: 822: * than the sizeof an MPI_Aint. 2214: -: 823: */ 2215: #####: 824: last_end = (char*) MPI_AINT_CAST_TO_VOID_PTR 2222: -: 831: * sum fits in a pointer. Just let it truncate. 2223: -: 832: */ 2224: #####: 833: if ((last_idx == paramp->length-1) && 2232: -: 837: * the end of the last one. 2233: -: 838: */ 2234: #####: 839: *blocks_p -= ((DLOOP_Offset) blocks_left + 2235: -: 840: (((DLOOP_Offset) size) / el_size)); 2236: #####: 841: return 1; 2237: -: 842: } 2238: #####: 843: else if (last_idx >= 0 && (last_end == ((char *) bufp + rel_off))) 2243: -: 844: { 2244: -: 845: /* add this size to the last vector rather than using up new one */ 2245: #####: 846: paramp->blklens[last_idx] += size; 2250: -: 851: * Just let it sign extend. 2251: -: 852: */ 2252: #####: 853: paramp->disps[last_idx+1] = MPI_PTR_DISP_CAST_TO_MPI_AINT bufp + 2253: -: 854: rel_off + offsetarray[i]; 2254: #####: 855: paramp->blklens[last_idx+1] = size; 2255: #####: 856: paramp->index++; 2260: -: 861: * blocks_p 2261: -: 862: */ 2262: #####: 863: DLOOP_Assert(blocks_left == 0); 2265: call 2 never executed 2266: call 3 never executed 2267: #####: 864: return 0; 2338: -: 919: * the end of the last one. 2339: -: 920: */ 2340: #####: 921: *blocks_p -= (blocks_left + (size / (int) el_size)); 2341: #####: 922: return 1; 58 line(s) not covered by tests in src/mpid/common/datatype/dataloop/segment_ops.c.gcov Uncovered lines in src/mpid/common/datatype/dataloop/dataloop_create_contig.c.gcov 142: branch 1 taken 100% 143: -: 88: { 144: #####: 89: count *= basic_sz; 145: #####: 90: new_dlp->el_size = 1; 146: #####: 91: new_dlp->el_extent = 1; 147: #####: 92: new_dlp->el_type = MPI_BYTE; 4 line(s) not covered by tests in src/mpid/common/datatype/dataloop/dataloop_create_contig.c.gcov Uncovered lines in src/mpid/common/datatype/dataloop/dataloop_create_indexed.c.gcov 69: branch 1 taken 100% 70: -: 62: { 71: #####: 63: err = PREPEND_PREFIX(Dataloop_create_contiguous)(0, 76: -: 67: dldepth_p, 77: -: 68: flag); 78: #####: 69: return err; 264: -: 205: { 265: -: 206: /* blocklengths are modified below */ 266: #####: 207: new_dlp->el_size = 1; 267: #####: 208: new_dlp->el_extent = 1; 268: #####: 209: new_dlp->el_type = MPI_BYTE; 355: -: 260: { 356: -: 261: DLOOP_Count *tmp_blklen_array = 357: #####: 262: new_dlp->loop_params.i_t.blocksize_array; 358: -: 263: 359: #####: 264: for (i=0; i < contig_count; i++) 362: -: 265: { 363: -: 266: /* increase block lengths so they are in bytes */ 364: #####: 267: tmp_blklen_array[i] *= old_extent; 365: -: 268: } 366: -: 269: 367: #####: 270: new_dlp->loop_params.i_t.total_blocks *= old_extent; 423: branch 1 taken 100% 424: -: 316: { 425: #####: 317: continue; 10 line(s) not covered by tests in src/mpid/common/datatype/dataloop/dataloop_create_indexed.c.gcov Uncovered lines in src/mpid/common/datatype/dataloop/dataloop_create_pairtype.c.gcov 89: 6546: 68: break; 90: -: 69: case MPI_2INT: 91: #####: 70: PAIRTYPE_CONTENTS(MPI_INT, int, MPI_INT, int); 1 line(s) not covered by tests in src/mpid/common/datatype/dataloop/dataloop_create_pairtype.c.gcov All code covered by tests in src/mpid/ch3/channels/ssm/src/ch3_finalize.c.gcov Uncovered lines in src/mpid/ch3/channels/ssm/src/ch3_init.c.gcov 228: -: 188:int MPIDI_CH3_RMAFnsInit( MPIDI_RMAFns *a ) 229: function MPIDI_CH3_RMAFnsInit called 0 returned 0% blocks executed 0% 230: #####: 189:{ 231: #####: 190: return 0; 257: -: 212:const char * MPIDI_CH3_VC_GetStateString( struct MPIDI_VC *vc ) 258: function MPIDI_CH3_VC_GetStateString called 0 returned 0% blocks executed 0% 259: #####: 213:{ 264: -: 218: /* return MPIDI_CH3_VC_SockGetStateString( vc );*/ 265: -: 219:#else 266: #####: 220: return "unknown"; 4 line(s) not covered by tests in src/mpid/ch3/channels/ssm/src/ch3_init.c.gcov Uncovered lines in src/mpid/ch3/channels/ssm/src/ch3_istartmsg.c.gcov 144: -: 109: /*MPIDI_CH3I_SSM_VC_post_write(vc, sreq);*/ 145: -: 110: MPIDI_DBG_PRINTF((55, FCNAME, "posting write, vc=0x%p, sreq=0x%08x", vc, sreq->handle)); 146: #####: 111: vcch->conn->send_active = sreq; 147: -: 112: /* We have to post this one since we're adding it 148: -: 113: to the head of the queue */ 149: #####: 114: mpi_errno = MPIDU_Sock_post_write(vcch->conn->sock, 152: -: 116: sreq->dev.iov[0].MPID_IOV_LEN, 153: -: 117: sreq->dev.iov[0].MPID_IOV_LEN, NULL); 154: #####: 118: if (mpi_errno != MPI_SUCCESS) 160: -: 121: "**ch3|sock|postwrite", "ch3|sock|postwrite %p %p %p", 161: -: 122: sreq, vcch->conn, vc); 162: #####: 123: goto fn_exit; 167: -: 128: else 168: -: 129: { 169: #####: 130: sreq = MPID_Request_create(); 170: call 0 never executed 171: #####: 131: if (sreq == NULL) 175: -: 132: { 176: call 0 never executed 177: #####: 134: goto fn_exit; 178: -: 135: } 179: #####: 136: sreq->kind = MPID_REQUEST_SEND; 180: #####: 137: sreq->cc = 0; 205: -: 153: 206: -: 154: /* queue the data so it can be sent after the connection is formed */ 207: #####: 155: mpi_errno = createRequest( pkt, pkt_sz, 0, &sreq ); 211: branch 1 never executed 212: call 2 never executed 213: #####: 157: MPIDI_CH3I_SendQ_enqueue(vcch, sreq); 236: call 0 returned 100% 237: -: 170: } 238: #####: 171: else if (vcch->state != MPIDI_CH3I_VC_STATE_FAILED) 242: -: 173: /* Unable to send data at the moment, so queue it for later */ 243: -: 174: MPIDI_DBG_PRINTF((55, FCNAME, "forming connection, request enqueued")); 244: #####: 175: mpi_errno = createRequest( pkt, pkt_sz, 0, &sreq ); 248: branch 1 never executed 249: call 2 never executed 250: #####: 177: MPIDI_CH3I_SendQ_enqueue(vcch, sreq); 256: -: 181: /* Connection failed, so allocate a request and return an error. */ 257: -: 182: MPIDI_DBG_PRINTF((55, FCNAME, "ERROR - connection failed")); 258: #####: 183: sreq = MPID_Request_create(); 259: call 0 never executed 260: #####: 184: if (sreq == NULL) { 265: -: 186: "**nomem %s","MPID_Request"); 266: -: 187: } 267: #####: 188: sreq->kind = MPID_REQUEST_SEND; 268: #####: 189: sreq->cc = 0; 269: -: 190: /* TODO: Create an appropriate error message */ 270: #####: 191: sreq->status.MPI_ERROR = MPI_ERR_INTERN; 19 line(s) not covered by tests in src/mpid/ch3/channels/ssm/src/ch3_istartmsg.c.gcov Uncovered lines in src/mpid/ch3/channels/ssm/src/ch3_istartmsgv.c.gcov 207: -: 152: /*MPIDI_CH3I_SSM_VC_post_write(vc, sreq);*/ 208: -: 153: MPIDI_DBG_PRINTF((55, FCNAME, "posting writev, vc=0x%p, sreq=0x%08x", vc, sreq->handle)); 209: #####: 154: vcch->conn->send_active = sreq; 210: #####: 155: mpi_errno = MPIDU_Sock_post_writev(vcch->conn->sock, sreq->dev.iov + offset, 211: call 0 never executed 212: -: 156: sreq->dev.iov_count - offset, NULL); 213: #####: 157: if (mpi_errno != MPI_SUCCESS) 233: -: 174: { 234: -: 175: MPIDI_DBG_PRINTF((55, FCNAME, "ERROR - MPIDI_CH3I_SHM_writev failed")); 235: #####: 176: sreq = MPID_Request_create(); 236: call 0 never executed 237: #####: 177: if (sreq == NULL) 241: -: 178: { 242: call 0 never executed 243: #####: 180: goto fn_exit; 244: -: 181: } 245: #####: 182: sreq->kind = MPID_REQUEST_SEND; 246: #####: 183: sreq->cc = 0; 303: -: 206: 304: -: 207: /* queue the data so it can be sent after the connection is formed */ 305: #####: 208: create_request(sreq, iov, n_iov, 0, 0); 333: call 27 never executed 334: call 28 never executed 335: #####: 209: MPIDI_CH3I_SendQ_enqueue(vcch, sreq); 397: -: 232: { 398: call 0 never executed 399: #####: 234: goto fn_exit; 400: -: 235: } 401: -: 236: } 402: #####: 237: else if (vcch->state != MPIDI_CH3I_VC_STATE_FAILED) 406: -: 239: /* Unable to send data at the moment, so queue it for later */ 407: -: 240: MPIDI_DBG_PRINTF((55, FCNAME, "forming connection, request enqueued")); 408: #####: 241: create_request(sreq, iov, n_iov, 0, 0); 444: -: 248: } 445: -: 249: */ 446: #####: 250: MPIDI_CH3I_SendQ_enqueue(vcch, sreq); 452: -: 254: /* Connection failed, so allocate a request and return an error. */ 453: -: 255: MPIDI_DBG_PRINTF((55, FCNAME, "ERROR - connection failed")); 454: #####: 256: sreq = MPID_Request_create(); 455: call 0 never executed 456: #####: 257: if (sreq == NULL) 460: -: 258: { 461: call 0 never executed 462: #####: 260: goto fn_exit; 463: -: 261: } 464: #####: 262: sreq->kind = MPID_REQUEST_SEND; 465: #####: 263: sreq->cc = 0; 466: -: 264: /* TODO: Create an appropriate error message */ 467: #####: 265: sreq->status.MPI_ERROR = MPI_ERR_INTERN; 20 line(s) not covered by tests in src/mpid/ch3/channels/ssm/src/ch3_istartmsgv.c.gcov All code covered by tests in src/mpid/ch3/channels/ssm/src/mpiimpl.h.gcov Uncovered lines in src/mpid/ch3/channels/ssm/src/ch3_isend.c.gcov 117: -: 88: else { 118: -: 89: int complete; 119: #####: 90: mpi_errno = reqFn( vc, sreq, &complete ); 123: branch 1 never executed 124: call 2 never executed 125: #####: 92: if (!complete) { 126: branch 0 never executed 127: branch 1 never executed 128: #####: 93: sreq->dev.iov_offset = 0; 129: #####: 94: MPIDI_CH3I_SendQ_enqueue_head(vcch, sreq); 130: branch 0 never executed 131: branch 1 never executed 132: #####: 95: if (vcch->bShm) 134: branch 1 never executed 135: -: 96: { 136: #####: 97: vcch->send_active = sreq; 138: -: 99: else 139: -: 100: { 140: #####: 101: vcch->conn->send_active = sreq; 141: #####: 102: mpi_errno = MPIDU_Sock_post_writev(vcch->conn->sock, sreq->dev.iov, sreq->dev.iov_count, NULL); 142: call 0 never executed 143: #####: 103: if (mpi_errno != MPI_SUCCESS) 169: -: 122: else 170: -: 123: { 171: #####: 124: vcch->conn->send_active = sreq; 172: #####: 125: mpi_errno = MPIDU_Sock_post_write(vcch->conn->sock, sreq->dev.iov[0].MPID_IOV_BUF, 173: call 0 never executed 174: -: 126: sreq->dev.iov[0].MPID_IOV_LEN, sreq->dev.iov[0].MPID_IOV_LEN, NULL); 175: #####: 127: if (mpi_errno != MPI_SUCCESS) 187: -: 136: else 188: -: 137: { 189: #####: 138: vcch->state = MPIDI_CH3I_VC_STATE_FAILED; 192: call 0 never executed 193: -: 141: /* MT -CH3U_Request_complete() performs write barrier */ 194: #####: 142: MPIDI_CH3U_Request_complete(sreq); 219: -: 154: /* Queuing the data so it can be sent later. */ 220: -: 155: MPIDI_DBG_PRINTF((55, FCNAME, "connecting. enqueuing request")); 221: #####: 156: update_request(sreq, pkt, pkt_sz, 0); 222: #####: 157: MPIDI_CH3I_SendQ_enqueue(vcch, sreq); 244: -: 169: } 245: -: 170: } 246: #####: 171: else if (vcch->state != MPIDI_CH3I_VC_STATE_FAILED) 250: -: 173: /* Unable to send data at the moment, so queue it for later */ 251: -: 174: MPIDI_DBG_PRINTF((55, FCNAME, "still connecting. enqueuing request")); 252: #####: 175: update_request(sreq, pkt, pkt_sz, 0); 253: #####: 176: MPIDI_CH3I_SendQ_enqueue(vcch, sreq); 261: -: 182: /* FIXME: For fault tolerance, retry the operation before marking the 262: -: 183: connection as failed */ 263: #####: 184: sreq->status.MPI_ERROR = MPI_ERR_INTERN; 264: -: 185: /* MT - CH3U_Request_complete() performs write barrier */ 265: #####: 186: MPIDI_CH3U_Request_complete(sreq); 21 line(s) not covered by tests in src/mpid/ch3/channels/ssm/src/ch3_isend.c.gcov Uncovered lines in src/mpid/ch3/channels/ssm/src/ch3_isendv.c.gcov 146: -: 118: /*MPIDI_CH3I_SSM_VC_post_write(vc, sreq);*/ 147: -: 119: MPIDI_DBG_PRINTF((55, FCNAME, "posting writev, vc=0x%p, sreq=0x%08x", vc, sreq->handle)); 148: #####: 120: vcch->conn->send_active = sreq; 149: #####: 121: mpi_errno = MPIDU_Sock_post_writev(vcch->conn->sock, sreq->dev.iov + offset, 150: call 0 never executed 151: -: 122: sreq->dev.iov_count - offset, NULL); 152: #####: 123: if (mpi_errno != MPI_SUCCESS) 214: -: 155: { 215: -: 156: MPIDI_DBG_PRINTF((55, FCNAME, "posting writev, vc=0x%p, sreq=0x%08x", vc, sreq->handle)); 216: #####: 157: vcch->conn->send_active = sreq; 217: #####: 158: mpi_errno = MPIDU_Sock_post_writev(vcch->conn->sock, sreq->dev.iov, sreq->dev.iov_count, NULL); 218: call 0 never executed 219: #####: 159: if (mpi_errno != MPI_SUCCESS) 233: -: 170: else 234: -: 171: { 235: #####: 172: vcch->state = MPIDI_CH3I_VC_STATE_FAILED; 238: call 0 never executed 239: -: 175: /* MT - CH3U_Request_complete performs write barrier */ 240: #####: 176: MPIDI_CH3U_Request_complete(sreq); 294: call 2 never executed 295: -: 202: } 296: #####: 203: else if (vcch->state != MPIDI_CH3I_VC_STATE_FAILED) 300: -: 205: /* Unable to send data at the moment, so queue it for later */ 301: -: 206: MPIDI_DBG_PRINTF((55, FCNAME, "still connecting. enqueuing request")); 302: #####: 207: update_request(sreq, iov, n_iov, 0, 0); 303: branch 0 never executed 304: branch 1 never executed 305: #####: 208: MPIDI_CH3I_SendQ_enqueue(vcch, sreq); 311: -: 212: /* Connection failed. Mark the request complete and return an error. */ 312: -: 213: /* TODO: Create an appropriate error message */ 313: #####: 214: sreq->status.MPI_ERROR = MPI_ERR_INTERN; 314: -: 215: /* MT - CH3U_Request_complete performs write barrier */ 315: #####: 216: MPIDI_CH3U_Request_complete(sreq); 13 line(s) not covered by tests in src/mpid/ch3/channels/ssm/src/ch3_isendv.c.gcov Uncovered lines in src/mpid/ch3/channels/ssm/src/ch3_progress.c.gcov 98: -: 81: { 99: call 0 never executed 100: #####: 83: goto fn_exit; 108: -: 90: /*MPIDI_err_printf("MPIDI_CH3_Progress", "MPIDI_CH3I_SHM_read_progress returned error %d\n", rc);*/ 109: call 0 never executed 110: #####: 92: goto fn_exit; 140: -: 110: { 141: call 0 never executed 142: #####: 112: goto fn_exit; 164: -: 131: else { 165: -: 132: MPIDI_FUNC_ENTER(MPID_STATE_MPIDU_YIELD); 166: #####: 133: MPIDU_Yield(); 190: -: 147: { 191: call 0 never executed 192: #####: 149: goto fn_exit; 201: -: 155: { 202: call 0 never executed 203: #####: 157: goto fn_exit; 229: -: 174: { 230: call 0 never executed 231: #####: 176: goto fn_exit; 265: -: 201: { 266: call 0 never executed 267: #####: 203: goto fn_exit; 1280: branch 1 taken 100% 1281: -: 1188: { 1282: #####: 1189: vcch = (MPIDI_CH3I_VC *)MPIDI_CH3I_Process.shm_reading_list->channel_private; 1283: #####: 1190: MPIDI_CH3I_SHM_Release_mem(&vcch->shm_read_queue_info); 1284: call 0 never executed 1285: #####: 1191: MPIDI_CH3I_Process.shm_reading_list = vcch->shm_next_reader; 1289: branch 1 taken 100% (fallthrough) 1290: -: 1194: { 1291: #####: 1195: vcch = (MPIDI_CH3I_VC *)MPIDI_CH3I_Process.shm_writing_list->channel_private; 1292: #####: 1196: MPIDI_CH3I_SHM_Release_mem(&vcch->shm_write_queue_info); 1293: call 0 never executed 1294: #####: 1197: MPIDI_CH3I_Process.shm_writing_list = vcch->shm_next_writer; 14 line(s) not covered by tests in src/mpid/ch3/channels/ssm/src/ch3_progress.c.gcov Uncovered lines in src/mpid/ch3/channels/ssm/src/ch3_shm_memory.c.gcov 82: branch 0 taken 0% (fallthrough) 83: branch 1 taken 100% 84: #####: 67: pOutput->error = errno; 85: call 0 never executed 86: #####: 68: perror("shm_open error"); 107: branch 0 taken 0% (fallthrough) 108: branch 1 taken 100% 109: #####: 81: pOutput->addr = NULL; 110: #####: 82: perror("mmap failed"); 157: branch 1 taken 100% 158: -: 123: { 159: #####: 124: pOutput->error = errno; 164: call 0 never executed 165: call 1 never executed 166: #####: 128: return mpi_errno; 179: call 0 never executed 180: call 1 never executed 181: #####: 138: return mpi_errno; 7 line(s) not covered by tests in src/mpid/ch3/channels/ssm/src/ch3_shm_memory.c.gcov Uncovered lines in src/mpid/ch3/channels/ssm/src/ch3_progress_shm.c.gcov 106: -: 88: { 107: call 0 never executed 108: #####: 91: return mpi_errno; 225: branch 1 taken 100% 226: -: 171: { 227: #####: 173: return MPI_SUCCESS; 295: -: 217: } 296: -: 218:#endif 297: #####: 220: return MPI_SUCCESS; 3 line(s) not covered by tests in src/mpid/ch3/channels/ssm/src/ch3_progress_shm.c.gcov Uncovered lines in src/mpid/ch3/channels/ssm/src/ch3_progress_sock.c.gcov 45: branch 1 taken 100% 46: -: 38: { 47: #####: 39: mpi_errno = MPIDU_Sock_post_writev( 49: -: 40: conn->sock, conn->send_active->dev.iov, 50: -: 41: conn->send_active->dev.iov_count, NULL); 51: #####: 42: if (mpi_errno != MPI_SUCCESS) { 133: -: 111: else 134: -: 112: { 135: #####: 113: iov[offset].MPID_IOV_BUF = (MPID_IOV_BUF_CAST)((char *) iov[offset].MPID_IOV_BUF + nb); 136: #####: 114: iov[offset].MPID_IOV_LEN -= nb; 137: #####: 115: break; 357: -: 266: (MPIU_DBG_FDEST,"posting readv, vc=%p, rreq=0x%08x", 358: -: 267: conn->vc, rreq->handle)); 359: #####: 268: conn->recv_active = rreq; 360: #####: 269: mpi_errno = MPIDU_Sock_post_readv(conn->sock, iovp, rreq->dev.iov_count, NULL); 381: -: 286: { 382: -: 287: int (*reqFn)(MPIDI_VC_t *, MPID_Request *, int *); 383: #####: 288: reqFn = rreq->dev.OnDataAvail; 384: #####: 289: if (!reqFn) { 385: branch 0 never executed 386: branch 1 never executed 387: #####: 290: MPIDI_CH3U_Request_complete(rreq); 395: branch 7 never executed 396: call 8 never executed 397: #####: 291: complete = TRUE; 398: -: 292: } 399: -: 293: else { 400: #####: 294: mpi_errno = reqFn( conn->vc, rreq, &complete ); 406: -: 296: } 407: -: 297: 408: #####: 298: if (complete) 410: branch 1 never executed 411: -: 299: { 412: #####: 300: conn->recv_active = NULL; 413: #####: 301: mpi_errno = connection_post_recv_pkt(conn); 414: call 0 never executed 415: #####: 302: if (mpi_errno != MPI_SUCCESS) { 427: -: 311: MPIU_Size_t nb; 428: -: 312: 429: #####: 313: iovp = rreq->dev.iov; 430: -: 314: 431: #####: 315: mpi_errno = MPIDU_Sock_readv(conn->sock, iovp, rreq->dev.iov_count, &nb); 448: -: 328: conn->vc, nb, rreq->handle)); 449: -: 329: 450: #####: 330: if (nb > 0 && adjust_iov(&iovp, &rreq->dev.iov_count, nb)) 456: -: 331: { 457: -: 332: int (*reqFn)(MPIDI_VC_t *, MPID_Request *, int *); 458: #####: 333: reqFn = rreq->dev.OnDataAvail; 459: #####: 334: if (!reqFn) { 460: branch 0 never executed 461: branch 1 never executed 462: #####: 335: MPIDI_CH3U_Request_complete(rreq); 470: branch 7 never executed 471: call 8 never executed 472: #####: 336: complete = TRUE; 473: -: 337: } 474: -: 338: else { 475: #####: 339: mpi_errno = reqFn( conn->vc, rreq, &complete ); 481: -: 341: } 482: -: 342: 483: #####: 343: if (complete) 485: branch 1 never executed 486: -: 344: { 487: #####: 345: conn->recv_active = NULL; 488: #####: 346: mpi_errno = connection_post_recv_pkt(conn); 489: call 0 never executed 490: #####: 347: if (mpi_errno != MPI_SUCCESS) { 504: -: 358: conn->vc, rreq->handle)); 505: -: 359: /* conn->recv_active = rreq; -- already set to current request */ 506: #####: 360: mpi_errno = MPIDU_Sock_post_readv(conn->sock, iovp, rreq->dev.iov_count, NULL); 691: -: 511: } 692: -: 512: else { 693: #####: 513: mpi_errno = reqFn( conn->vc, sreq, &complete ); 721: -: 529: MPIU_Size_t nb; 722: -: 530: 723: #####: 531: iovp = sreq->dev.iov; 724: -: 532: 725: #####: 533: mpi_errno = MPIDU_Sock_writev(conn->sock, iovp, sreq->dev.iov_count, &nb); 741: -: 545: conn->vc, sreq->handle, nb)); 742: -: 546: 743: #####: 547: if (nb > 0 && adjust_iov(&iovp, &sreq->dev.iov_count, nb)) 749: -: 548: { 750: -: 549: int (*reqFn)(MPIDI_VC_t *, MPID_Request *, int *); 751: #####: 550: reqFn = sreq->dev.OnDataAvail; 752: #####: 551: if (!reqFn) { 753: branch 0 never executed 754: branch 1 never executed 755: #####: 552: MPIDI_CH3U_Request_complete(sreq); 763: branch 7 never executed 764: call 8 never executed 765: #####: 553: complete = TRUE; 766: -: 554: } 767: -: 555: else { 768: #####: 556: mpi_errno = reqFn( conn->vc, sreq, &complete ); 774: -: 558: } 775: -: 559: 776: #####: 560: if (complete) 778: branch 1 never executed 779: -: 561: { 780: #####: 562: MPIDI_CH3I_VC *vcch = (MPIDI_CH3I_VC *)conn->vc->channel_private; 781: #####: 563: MPIDI_CH3I_SendQ_dequeue(vcch); 782: branch 0 never executed 783: branch 1 never executed 784: #####: 564: mpi_errno = connection_post_sendq_req(conn); 785: call 0 never executed 786: #####: 565: if (mpi_errno) { 796: -: 572: { 797: -: 573: MPIDI_DBG_PRINTF((55, FCNAME, "posting writev, vc=0x%p, sreq=0x%08x", conn->vc, sreq->handle)); 798: #####: 574: mpi_errno = MPIDU_Sock_post_writev(conn->sock, iovp, sreq->dev.iov_count, NULL); 908: -: 664: case MPIDU_SOCK_OP_WAKEUP: 909: -: 665: { 910: #####: 666: MPIDI_CH3_Progress_signal_completion(); 45 line(s) not covered by tests in src/mpid/ch3/channels/ssm/src/ch3_progress_sock.c.gcov Uncovered lines in src/mpid/ch3/channels/ssm/src/ch3_progress_connect.c.gcov 47: branch 1 taken 100% 48: call 0 never executed 49: #####: 35: goto fn_exit; 250: branch 1 taken 100% 251: -: 205: { 252: #####: 206: *flag = FALSE; 253: #####: 206: *flag = FALSE; 254: call 0 never executed 255: #####: 208: return mpi_errno; 274: branch 2 taken 100% 275: -: 225: { 276: #####: 226: *flag = FALSE; 277: #####: 227: return MPI_SUCCESS; 287: branch 1 taken 100% 288: -: 235: { 289: #####: 236: *flag = FALSE; 290: #####: 237: return MPI_SUCCESS; 299: branch 1 taken 100% 300: -: 244: { 301: #####: 245: *flag = FALSE; 302: #####: 245: *flag = FALSE; 303: call 0 never executed 304: #####: 247: return mpi_errno; 332: branch 1 taken 100% 333: -: 269: { 334: #####: 270: MPIDI_CH3I_SHM_Unlink_mem(&vcch->shm_write_queue_info); 335: call 0 never executed 336: #####: 271: MPIDI_CH3I_SHM_Release_mem(&vcch->shm_write_queue_info); 337: call 0 never executed 338: #####: 272: *flag = FALSE; 339: #####: 272: *flag = FALSE; 340: call 0 never executed 341: #####: 274: return mpi_errno; 350: branch 1 taken 100% 351: -: 281: { 352: #####: 282: MPIDI_CH3I_SHM_Unlink_mem(&vcch->shm_write_queue_info); 353: call 0 never executed 354: #####: 283: MPIDI_CH3I_SHM_Release_mem(&vcch->shm_write_queue_info); 355: call 0 never executed 356: #####: 284: *flag = FALSE; 357: #####: 284: *flag = FALSE; 358: call 0 never executed 359: #####: 286: return mpi_errno; 560: -: 467:void MPIDI_CH3I_Connection_free(MPIDI_CH3I_Connection_t * conn) 561: function MPIDI_CH3I_Connection_free called 0 returned 0% blocks executed 0% 562: #####: 468:{ 565: -: 471: MPIDI_FUNC_ENTER(MPID_STATE_MPIDI_CH3I_CONNECTION_FREE); 566: -: 472: 567: #####: 473: MPIU_Free(conn->pg_id); 568: call 0 never executed 569: #####: 474: MPIU_Free(conn); 20 line(s) not covered by tests in src/mpid/ch3/channels/ssm/src/ch3_progress_connect.c.gcov All code covered by tests in src/mpid/ch3/src/stdlib.h.gcov Uncovered lines in src/mpid/ch3/src/ch3u_buffer.c.gcov 301: -: 210: MPIU_DBG_MSG_FMT(CH3_OTHER, VERBOSE, (MPIU_DBG_FDEST, 302: -: 211: "moved " MPIDI_MSG_SZ_FMT " bytes to the beginning of the tmp buffer", buf_off)); 303: #####: 212: memmove(buf, buf_end - buf_off, buf_off); 1 line(s) not covered by tests in src/mpid/ch3/src/ch3u_buffer.c.gcov All code covered by tests in src/mpid/ch3/src/mpiimpl.h.gcov Uncovered lines in src/mpid/ch3/src/ch3u_comm_spawn_multiple.c.gcov 65: branch 0 taken 0% (fallthrough) 66: branch 1 taken 100% 67: #####: 51: goto fn_exit; 205: branch 0 taken 0% (fallthrough) 206: branch 1 taken 100% 207: #####: 142: for (i=0; ipg); 342: branch 0 taken 0% (fallthrough) 343: branch 1 taken 100% 344: #####: 271: printf( "Unexpected state %d in vc %p\n", vc->state, vc ); 345: call 0 never executed 346: #####: 272: fflush(stdout); 3 line(s) not covered by tests in src/mpid/ch3/src/ch3u_handle_connection.c.gcov Uncovered lines in src/mpid/ch3/src/ch3u_handle_recv_pkt.c.gcov 59: -: 54: MPIDI_msg_sz_t *buflen, MPID_Request ** rreqp) 60: function MPIDI_CH3U_Handle_recv_pkt called 0 returned 0% blocks executed 0% 61: #####: 55:{ 62: #####: 56: int mpi_errno = MPI_SUCCESS; 77: -: 71: */ 78: -: 72: 79: #####: 73: if (needsInit) { 80: branch 0 never executed 81: branch 1 never executed 82: #####: 74: MPIDI_CH3_PktHandler_Init( pktArray, MPIDI_CH3_PKT_END_CH3 ); 83: call 0 never executed 84: #####: 75: needsInit = 0; 85: -: 76: } 86: -: 77: /* Packet type is an enum and hence >= 0 */ 87: #####: 78: MPIU_Assert(pkt->type <= MPIDI_CH3_PKT_END_CH3); 90: call 2 never executed 91: call 3 never executed 92: #####: 79: mpi_errno = pktArray[pkt->type](vc, pkt, buflen, rreqp); 94: call 0 never executed 95: -: 80: 96: #####: 82: return mpi_errno; 178: -: 147: MPIU_DBG_MSG(CH3_OTHER,VERBOSE,"Copying contiguous data to user buffer"); 179: -: 148: /* copy data out of the receive buffer */ 180: #####: 149: MPIU_Memcpy((char*)(rreq->dev.user_buf) + dt_true_lb, buf, data_sz); 204: call 23 never executed 205: call 24 never executed 206: #####: 150: *buflen = data_sz; 207: #####: 151: *complete = TRUE; 252: -: 187: MPIDI_msg_sz_t last; 253: -: 188: MPIU_DBG_MSG(CH3_OTHER,VERBOSE,"Copying noncontiguous data to user buffer"); 254: #####: 189: last = data_sz; 255: #####: 190: MPID_Segment_unpack(rreq->dev.segment_ptr, rreq->dev.segment_first, 273: call 0 never executed 274: -: 191: &last, buf); 275: #####: 206: *buflen = data_sz; 276: #####: 207: rreq->dev.OnDataAvail = 0; 277: #####: 208: *complete = TRUE; 336: branch 1 taken 100% 337: -: 257: { 338: #####: 258: MPIU_Memcpy(rreq->dev.tmpbuf, buf, rreq->dev.recv_data_sz); 362: call 23 never executed 363: call 24 never executed 364: #####: 259: *buflen = rreq->dev.recv_data_sz; 365: #####: 260: rreq->dev.recv_pending_count = 1; 366: #####: 261: *complete = TRUE; 394: -: 289:int MPIDI_CH3U_Post_data_receive_found(MPID_Request * rreq) 395: function MPIDI_CH3U_Post_data_receive_found called 0 returned 0% blocks executed 0% 396: #####: 290:{ 397: #####: 291: int mpi_errno = MPI_SUCCESS; 399: -: 293: MPI_Aint dt_true_lb; 400: -: 294: MPIDI_msg_sz_t userbuf_sz; 401: #####: 295: MPID_Datatype * dt_ptr = NULL; 407: -: 301: MPIU_DBG_MSG(CH3_OTHER,VERBOSE,"posted request found"); 408: -: 302: 409: #####: 303: MPIDI_Datatype_get_info(rreq->dev.user_count, rreq->dev.datatype, 417: -: 304: dt_contig, userbuf_sz, dt_ptr, dt_true_lb); 418: -: 305: 419: #####: 306: if (rreq->dev.recv_data_sz <= userbuf_sz) { 420: branch 0 never executed 421: branch 1 never executed 422: #####: 307: data_sz = rreq->dev.recv_data_sz; 433: -: 317: rreq->status.MPI_SOURCE, rreq->status.MPI_TAG, 434: -: 318: rreq->dev.recv_data_sz, userbuf_sz ); 435: #####: 319: rreq->status.count = userbuf_sz; 436: #####: 320: data_sz = userbuf_sz; 437: -: 321: } 438: -: 322: 439: #####: 323: if (dt_contig && data_sz == rreq->dev.recv_data_sz) 447: -: 327: (this code describes how to read the data into the destination) */ 448: -: 328: MPIU_DBG_MSG(CH3_OTHER,VERBOSE,"IOV loaded for contiguous read"); 449: #####: 329: rreq->dev.iov[0].MPID_IOV_BUF = 450: -: 330: (MPID_IOV_BUF_CAST)((char*)(rreq->dev.user_buf) + dt_true_lb); 451: #####: 331: rreq->dev.iov[0].MPID_IOV_LEN = data_sz; 452: #####: 332: rreq->dev.iov_count = 1; 454: -: 334: function, which depends on whether this is an RMA 455: -: 335: request or a pt-to-pt request. */ 456: #####: 336: rreq->dev.OnDataAvail = 0; 460: -: 340: the entire message */ 461: -: 341: MPIU_DBG_MSG(CH3_OTHER,VERBOSE,"IOV loaded for non-contiguous read"); 462: #####: 342: rreq->dev.segment_ptr = MPID_Segment_alloc( ); 463: call 0 never executed 464: #####: 343: MPIU_ERR_CHKANDJUMP1((rreq->dev.segment_ptr == NULL), mpi_errno, MPI_ERR_OTHER, "**nomem", "**nomem %s", "MPID_Segment_alloc"); 466: branch 1 never executed 467: call 2 never executed 468: #####: 344: MPID_Segment_init(rreq->dev.user_buf, rreq->dev.user_count, 469: call 0 never executed 470: -: 345: rreq->dev.datatype, rreq->dev.segment_ptr, 0); 471: #####: 346: rreq->dev.segment_first = 0; 472: #####: 347: rreq->dev.segment_size = data_sz; 473: #####: 348: mpi_errno = MPIDI_CH3U_Request_load_recv_iov(rreq); 474: call 0 never executed 475: #####: 349: if (mpi_errno != MPI_SUCCESS) { 482: -: 353: } 483: -: 354: 484: #####: 355: fn_exit: 485: #####: 355: fn_exit: 486: #####: 357: return mpi_errno; 495: -: 366:int MPIDI_CH3U_Post_data_receive_unexpected(MPID_Request * rreq) 496: function MPIDI_CH3U_Post_data_receive_unexpected called 0 returned 0% blocks executed 0% 497: #####: 367:{ 498: #####: 368: int mpi_errno = MPI_SUCCESS; 507: -: 377: MPIU_DBG_MSG(CH3_OTHER,VERBOSE,"unexpected request allocated"); 508: -: 378: 509: #####: 379: rreq->dev.tmpbuf = MPIU_Malloc(rreq->dev.recv_data_sz); 510: call 0 never executed 511: #####: 380: if (!rreq->dev.tmpbuf) { 515: call 0 never executed 516: -: 382: } 517: #####: 383: rreq->dev.tmpbuf_sz = rreq->dev.recv_data_sz; 518: -: 384: 519: #####: 385: rreq->dev.iov[0].MPID_IOV_BUF = (MPID_IOV_BUF_CAST)rreq->dev.tmpbuf; 520: #####: 386: rreq->dev.iov[0].MPID_IOV_LEN = rreq->dev.recv_data_sz; 521: #####: 387: rreq->dev.iov_count = 1; 522: #####: 388: rreq->dev.OnDataAvail = MPIDI_CH3_ReqHandler_UnpackUEBufComplete; 523: #####: 389: rreq->dev.recv_pending_count = 2; 525: #####: 389: rreq->dev.recv_pending_count = 2; 526: -: 390: 527: #####: 393: return mpi_errno; 622: -: 479: MPIDI_msg_sz_t *buflen, MPID_Request **rreqp) 623: function MPIDI_CH3_PktHandler_FlowCntlUpdate called 0 returned 0% blocks executed 0% 624: #####: 480:{ 625: #####: 481: *buflen = sizeof(MPIDI_CH3_Pkt_t); 626: #####: 482: return MPI_SUCCESS; 637: -: 493: MPID_Request **rreqp ATTRIBUTE((unused)) ) 638: function MPIDI_CH3_PktHandler_EndCH3 called 0 returned 0% blocks executed 0% 639: #####: 494:{ 644: -: 498: 645: -: 500: 646: #####: 501: return MPI_SUCCESS; 58 line(s) not covered by tests in src/mpid/ch3/src/ch3u_handle_recv_pkt.c.gcov Uncovered lines in src/mpid/ch3/src/ch3u_handle_recv_req.c.gcov 25: -: 20: int * complete) 26: function MPIDI_CH3U_Handle_recv_req called 0 returned 0% blocks executed 0% 27: #####: 21:{ 28: -: 22: static int in_routine = FALSE; 29: #####: 23: int mpi_errno = MPI_SUCCESS; 33: -: 27: MPIDI_FUNC_ENTER(MPID_STATE_MPIDI_CH3U_HANDLE_RECV_REQ); 34: -: 28: 35: #####: 29: MPIU_Assert(in_routine == FALSE); 38: call 2 never executed 39: call 3 never executed 40: #####: 30: in_routine = TRUE; 41: -: 31: 42: #####: 32: reqFn = rreq->dev.OnDataAvail; 43: #####: 33: if (!reqFn) { 44: branch 0 never executed 45: branch 1 never executed 46: #####: 34: MPIU_Assert(MPIDI_Request_get_type(rreq) == MPIDI_REQUEST_TYPE_RECV); 49: call 2 never executed 50: call 3 never executed 51: #####: 35: MPIDI_CH3U_Request_complete(rreq); 59: branch 7 never executed 60: call 8 never executed 61: #####: 36: *complete = TRUE; 62: -: 37: } 63: -: 38: else { 64: #####: 39: mpi_errno = reqFn( vc, rreq, complete ); 66: -: 40: } 67: -: 41: 68: #####: 42: in_routine = FALSE; 69: #####: 42: in_routine = FALSE; 70: #####: 44: return mpi_errno; 94: -: 68: int *complete ) 95: function MPIDI_CH3_ReqHandler_RecvComplete called 0 returned 0% blocks executed 0% 96: #####: 69:{ 97: -: 70: /* mark data transfer as complete and decrement CC */ 98: #####: 71: MPIDI_CH3U_Request_complete(rreq); 106: branch 7 never executed 107: call 8 never executed 108: #####: 72: *complete = TRUE; 109: #####: 73: return MPI_SUCCESS; 484: -: 347: int *complete ) 485: function MPIDI_CH3_ReqHandler_SinglePutAccumComplete called 0 returned 0% blocks executed 0% 486: #####: 348:{ 487: #####: 349: int mpi_errno = MPI_SUCCESS; 497: -: 359: operation. */ 498: -: 360: 499: #####: 361: MPID_Win_get_ptr(rreq->dev.target_win_handle, win_ptr); 503: call 3 never executed 504: -: 362: 505: #####: 363: lock_queue_entry = rreq->dev.lock_queue_entry; 506: -: 364: 507: #####: 365: if (MPIDI_CH3I_Try_acquire_win_lock(win_ptr, 512: -: 367: { 513: -: 368: 514: #####: 369: if (MPIDI_Request_get_type(rreq) == MPIDI_REQUEST_TYPE_PT_SINGLE_PUT) { 516: branch 1 never executed 517: -: 370: /* copy the data over */ 518: #####: 371: mpi_errno = MPIR_Localcopy(rreq->dev.user_buf, 525: -: 377: } 526: -: 378: else { 527: #####: 379: mpi_errno = do_simple_accumulate(lock_queue_entry->pt_single_op); 529: -: 380: } 530: -: 381: 531: #####: 382: if (mpi_errno) { 537: -: 385: 538: -: 386: /* increment counter */ 539: #####: 387: win_ptr->my_pt_rma_puts_accs++; 540: -: 388: 541: -: 389: /* send done packet */ 542: #####: 390: mpi_errno = MPIDI_CH3I_Send_pt_rma_done_pkt(vc, 543: call 0 never executed 544: -: 391: lock_queue_entry->source_win_handle); 545: #####: 392: if (mpi_errno) { 552: -: 396: /* free lock_queue_entry including data buffer and remove 553: -: 397: it from the queue. */ 554: #####: 398: curr_ptr = (MPIDI_Win_lock_queue *) win_ptr->lock_queue; 555: #####: 399: curr_ptr_ptr = (MPIDI_Win_lock_queue **) &(win_ptr->lock_queue); 556: #####: 400: while (curr_ptr != lock_queue_entry) { 557: branch 0 never executed 558: branch 1 never executed 559: #####: 401: curr_ptr_ptr = &(curr_ptr->next); 560: #####: 402: curr_ptr = curr_ptr->next; 561: -: 403: } 562: #####: 404: *curr_ptr_ptr = curr_ptr->next; 563: -: 405: 564: #####: 406: MPIU_Free(lock_queue_entry->pt_single_op->data); 565: call 0 never executed 566: #####: 407: MPIU_Free(lock_queue_entry->pt_single_op); 567: call 0 never executed 568: #####: 408: MPIU_Free(lock_queue_entry); 570: -: 409: 571: -: 410: /* Release lock and grant next lock if there is one. */ 572: #####: 411: mpi_errno = MPIDI_CH3I_Release_lock(win_ptr); 575: -: 413: else { 576: -: 414: /* could not acquire lock. mark data recd as 1 */ 577: #####: 415: lock_queue_entry->pt_single_op->data_recd = 1; 579: -: 417: 580: -: 418: /* mark data transfer as complete and decrement CC */ 581: #####: 419: MPIDI_CH3U_Request_complete(rreq); 589: branch 7 never executed 590: call 8 never executed 591: #####: 420: *complete = TRUE; 592: call 8 never executed 593: #####: 420: *complete = TRUE; 594: #####: 423: return mpi_errno; 1051: branch 0 taken 0% (fallthrough) 1052: branch 1 taken 100% 1053: #####: 773: entered_count++; 1054: #####: 774: goto fn_exit; 1101: -: 808: MPIDI_PT_single_op * single_op; 1102: -: 809: 1103: #####: 810: single_op = lock_queue->pt_single_op; 1104: #####: 811: if (single_op->type == MPIDI_RMA_PUT) { 1105: branch 0 never executed 1106: branch 1 never executed 1107: #####: 812: mpi_errno = MPIR_Localcopy(single_op->data, 1113: -: 817: single_op->datatype); 1114: -: 818: } 1115: #####: 819: else if (single_op->type == MPIDI_RMA_ACCUMULATE) { 1116: branch 0 never executed 1117: branch 1 never executed 1118: #####: 820: mpi_errno = do_simple_accumulate(single_op); 1119: call 0 never executed 1120: -: 821: } 1121: #####: 822: else if (single_op->type == MPIDI_RMA_GET) { 1122: branch 0 never executed 1123: branch 1 never executed 1124: #####: 823: mpi_errno = do_simple_get(win_ptr, lock_queue); 1126: -: 824: } 1127: -: 825: 1128: #####: 826: if (mpi_errno != MPI_SUCCESS) goto fn_exit; 1131: -: 827: 1132: -: 828: /* if put or accumulate, send rma done packet and release lock. */ 1133: #####: 829: if (single_op->type != MPIDI_RMA_GET) { 1135: branch 1 never executed 1136: -: 830: /* increment counter */ 1137: #####: 831: win_ptr->my_pt_rma_puts_accs++; 1138: -: 832: 1139: #####: 833: mpi_errno = 1141: -: 834: MPIDI_CH3I_Send_pt_rma_done_pkt(lock_queue->vc, 1142: -: 835: lock_queue->source_win_handle); 1143: #####: 836: if (mpi_errno != MPI_SUCCESS) goto fn_exit; 1146: -: 837: 1147: -: 838: /* release the lock */ 1148: #####: 839: if (win_ptr->current_lock_type == MPI_LOCK_SHARED) { 1151: -: 840: /* decr ref cnt */ 1152: -: 841: /* FIXME: MT: Must be done atomically */ 1153: #####: 842: win_ptr->shared_lock_ref_cnt--; 1157: -: 846: (which is also true if the lock is an 1158: -: 847: exclusive lock), release the lock. */ 1159: #####: 848: if (win_ptr->shared_lock_ref_cnt == 0) { 1162: -: 849: /* FIXME: MT: The setting of the lock type 1163: -: 850: must be done atomically */ 1164: #####: 851: win_ptr->current_lock_type = MPID_LOCK_NONE; 1166: -: 853: 1167: -: 854: /* dequeue entry from lock queue */ 1168: #####: 855: MPIU_Free(single_op->data); 1169: call 0 never executed 1170: #####: 856: MPIU_Free(single_op); 1171: call 0 never executed 1172: #####: 857: *lock_queue_ptr = lock_queue->next; 1173: #####: 858: MPIU_Free(lock_queue); 1174: call 0 never executed 1175: #####: 859: lock_queue = *lock_queue_ptr; 1183: -: 867: next operation. */ 1184: -: 868: 1185: #####: 869: MPIU_Free(single_op); 1186: call 0 never executed 1187: #####: 870: *lock_queue_ptr = lock_queue->next; 1188: #####: 871: MPIU_Free(lock_queue); 1189: call 0 never executed 1190: #####: 872: lock_queue = *lock_queue_ptr; 1191: -: 873: 1192: #####: 874: if (requested_lock == MPI_LOCK_EXCLUSIVE) 1193: branch 0 never executed 1194: branch 1 never executed 1195: #####: 875: break; 1220: -: 896: } 1221: -: 897: else { 1222: #####: 898: lock_queue_ptr = &(lock_queue->next); 1223: #####: 899: lock_queue = lock_queue->next; 1271: branch 1 taken 100% 1272: -: 939: { 1273: #####: 940: MPID_Request_release(req); 1293: -: 953:static int do_simple_accumulate(MPIDI_PT_single_op *single_op) 1294: function do_simple_accumulate called 0 returned 0% blocks executed 0% 1295: #####: 954:{ 1296: #####: 955: int mpi_errno = MPI_SUCCESS; 1300: -: 959: MPIDI_FUNC_ENTER(MPID_STATE_DO_SIMPLE_ACCUMULATE); 1301: -: 960: 1302: #####: 961: if (single_op->op == MPI_REPLACE) 1305: -: 962: { 1306: -: 963: /* simply copy the data */ 1307: #####: 964: mpi_errno = MPIR_Localcopy(single_op->data, single_op->count, 1309: -: 965: single_op->datatype, single_op->addr, 1310: -: 966: single_op->count, single_op->datatype); 1311: #####: 967: if (mpi_errno) { 1318: -: 971: } 1319: -: 972: 1320: #####: 973: if (HANDLE_GET_KIND(single_op->op) == HANDLE_KIND_BUILTIN) 1323: -: 974: { 1324: -: 975: /* get the function by indexing into the op table */ 1325: #####: 976: uop = MPIR_Op_table[(single_op->op)%16 - 1]; 1335: -: 985: 1336: -: 986: /* only basic datatypes supported for this optimization. */ 1337: #####: 987: (*uop)(single_op->data, single_op->addr, 1340: -: 988: &(single_op->count), &(single_op->datatype)); 1341: -: 989: 1342: #####: 991: fn_exit: 1343: #####: 991: fn_exit: 1344: #####: 993: return mpi_errno; 1353: -: 1002:static int do_simple_get(MPID_Win *win_ptr, MPIDI_Win_lock_queue *lock_queue) 1354: function do_simple_get called 0 returned 0% blocks executed 0% 1355: #####: 1003:{ 1356: -: 1004: MPIDI_CH3_Pkt_t upkt; 1357: #####: 1005: MPIDI_CH3_Pkt_get_resp_t * get_resp_pkt = &upkt.get_resp; 1358: -: 1006: MPID_Request *req; 1359: -: 1007: MPID_IOV iov[MPID_IOV_LIMIT]; 1360: #####: 1008: int type_size, mpi_errno=MPI_SUCCESS; 1363: -: 1011: MPIDI_FUNC_ENTER(MPID_STATE_DO_SIMPLE_GET); 1364: -: 1012: 1365: #####: 1013: req = MPID_Request_create(); 1366: call 0 never executed 1367: #####: 1014: if (req == NULL) { 1371: call 0 never executed 1372: -: 1016: } 1373: #####: 1017: req->dev.target_win_handle = win_ptr->handle; 1374: #####: 1018: req->dev.source_win_handle = lock_queue->source_win_handle; 1375: #####: 1019: req->dev.single_op_opt = 1; 1376: -: 1020: 1377: #####: 1021: MPIDI_Request_set_type(req, MPIDI_REQUEST_TYPE_GET_RESP); 1378: #####: 1022: req->kind = MPID_REQUEST_SEND; 1379: #####: 1023: req->dev.OnDataAvail = MPIDI_CH3_ReqHandler_GetSendRespComplete; 1380: #####: 1024: req->dev.OnFinal = MPIDI_CH3_ReqHandler_GetSendRespComplete; 1381: -: 1025: 1382: #####: 1026: MPIDI_Pkt_init(get_resp_pkt, MPIDI_CH3_PKT_GET_RESP); 1383: #####: 1027: get_resp_pkt->request_handle = lock_queue->pt_single_op->request_handle; 1384: -: 1028: 1385: #####: 1029: iov[0].MPID_IOV_BUF = (MPID_IOV_BUF_CAST) get_resp_pkt; 1386: #####: 1030: iov[0].MPID_IOV_LEN = sizeof(*get_resp_pkt); 1387: -: 1031: 1388: #####: 1032: iov[1].MPID_IOV_BUF = (MPID_IOV_BUF_CAST)lock_queue->pt_single_op->addr; 1389: #####: 1033: MPID_Datatype_get_size_macro(lock_queue->pt_single_op->datatype, type_size); 1393: branch 3 never executed 1394: call 4 never executed 1395: #####: 1034: iov[1].MPID_IOV_LEN = lock_queue->pt_single_op->count * type_size; 1397: -: 1036: /* Because this is in a packet handler, it is already within a critical section */ 1398: -: 1037: /* MPIU_THREAD_CS_ENTER(CH3COMM,vc); */ 1399: #####: 1038: mpi_errno = MPIU_CALL(MPIDI_CH3,iSendv(lock_queue->vc, req, iov, 2)); 1416: -: 1048: 1417: -: 1051: 1418: #####: 1052: return mpi_errno; 105 line(s) not covered by tests in src/mpid/ch3/src/ch3u_handle_recv_req.c.gcov Uncovered lines in src/mpid/ch3/src/ch3u_handle_send_req.c.gcov 19: -: 14: int *complete) 20: function MPIDI_CH3U_Handle_send_req called 0 returned 0% blocks executed 0% 21: #####: 15:{ 22: #####: 16: int mpi_errno = MPI_SUCCESS; 28: -: 22: /* Use the associated function rather than switching on the old ca field */ 29: -: 23: /* Routines can call the attached function directly */ 30: #####: 24: reqFn = sreq->dev.OnDataAvail; 31: #####: 25: if (!reqFn) { 32: branch 0 never executed 33: branch 1 never executed 34: #####: 26: MPIU_Assert(MPIDI_Request_get_type(sreq) != MPIDI_REQUEST_TYPE_GET_RESP); 37: call 2 never executed 38: call 3 never executed 39: #####: 27: MPIDI_CH3U_Request_complete(sreq); 47: branch 7 never executed 48: call 8 never executed 49: #####: 28: *complete = 1; 50: -: 29: } 51: -: 30: else { 52: #####: 31: mpi_errno = reqFn( vc, sreq, complete ); 55: -: 32: } 56: -: 33: 57: #####: 35: return mpi_errno; 9 line(s) not covered by tests in src/mpid/ch3/src/ch3u_handle_send_req.c.gcov Uncovered lines in src/mpid/ch3/src/ch3u_port.c.gcov 769: branch 0 taken 0% (fallthrough) 770: branch 1 taken 100% 771: #####: 602: pg_trailer = pg_trailer->next; 820: 1073: 638: fn_exit: 821: 1073: 640: return mpi_errno; 822: #####: 642: MPIU_CHKPMEM_REAP(); 1026: branch 1 taken 100% 1027: -: 781: /* FIXME: Error, the pg_list is broken */ 1028: #####: 782: printf( "Unexpected end of pg_list\n" ); fflush(stdout); 1029: call 0 never executed 1030: call 1 never executed 1031: #####: 783: break; 1706: 536: 1301: acceptq_head = q_item->next; 1707: -: 1302: else 1708: #####: 1303: prev->next = q_item->next; 5 line(s) not covered by tests in src/mpid/ch3/src/ch3u_port.c.gcov Uncovered lines in src/mpid/ch3/src/ch3u_recvq.c.gcov 624: branch 0 taken 0% (fallthrough) 625: branch 1 taken 100% 626: #####: 497: goto top_loop; 790: -: 622:int MPIDI_CH3U_Recvq_count_unexp(void) 791: function MPIDI_CH3U_Recvq_count_unexp called 0 returned 0% blocks executed 0% 792: #####: 623:{ 793: #####: 624: int count = 0; 794: #####: 625: MPID_Request *req = recvq_unexpected_head; 795: -: 626: 796: #####: 627: while (req) 798: branch 1 never executed 799: -: 628: { 800: #####: 629: ++count; 801: #####: 630: req = req->dev.next; 802: -: 631: } 803: -: 632: 804: #####: 633: return count; 8 line(s) not covered by tests in src/mpid/ch3/src/ch3u_recvq.c.gcov Uncovered lines in src/mpid/ch3/src/ch3u_request.c.gcov 648: -: 468: MPIU_DBG_MSG(CH3_CHANNEL,VERBOSE, 649: -: 469: "updating rreq to read overflow data into the SRBuf and reload IOV"); 650: #####: 470: rreq->dev.iov[0].MPID_IOV_LEN = rreq->dev.tmpbuf_sz; 651: #####: 471: rreq->dev.segment_first += rreq->dev.tmpbuf_sz; 652: #####: 472: rreq->dev.OnDataAvail = MPIDI_CH3_ReqHandler_ReloadIOV; 745: -: 549: Note: memmove() is used since the data regions could 746: -: 550: overlap. */ 747: #####: 551: memmove(rreq->dev.tmpbuf, (char *) rreq->dev.tmpbuf + 4 line(s) not covered by tests in src/mpid/ch3/src/ch3u_request.c.gcov Uncovered lines in src/mpid/ch3/src/ch3u_rma_ops.c.gcov 256: -: 154: 257: -: 155: /* poke the progress engine until the two are equal */ 258: #####: 156: MPID_Progress_start(&progress_state); 259: #####: 157: while (total_pt_rma_puts_accs != (*win_ptr)->my_pt_rma_puts_accs) 261: branch 1 never executed 262: -: 158: { 263: #####: 159: mpi_errno = MPID_Progress_wait(&progress_state); 354: branch 1 taken 100% 355: -: 220: { 356: #####: 221: goto fn_exit; 520: branch 1 taken 100% 521: -: 323: { 522: #####: 324: goto fn_exit; 691: branch 1 taken 100% 692: -: 431: { 693: #####: 432: goto fn_exit; 730: branch 1 taken 100% 731: -: 453: { 732: #####: 454: mpi_errno = MPIR_Localcopy(origin_addr, origin_count, 735: -: 456: (char *) win_ptr->base + win_ptr->disp_unit * 736: -: 457: target_disp, target_count, target_datatype); 737: #####: 458: goto fn_exit; 821: -: 510: /* target predefined type, origin derived datatype */ 822: -: 511: 823: #####: 512: (*uop)(tmp_buf, (char *) win_ptr->base + win_ptr->disp_unit * 9 line(s) not covered by tests in src/mpid/ch3/src/ch3u_rma_ops.c.gcov Uncovered lines in src/mpid/ch3/src/ch3u_rma_sync.c.gcov 80: branch 1 taken 100% 81: -: 73: { 82: #####: 74: MPID_Progress_start(&progress_state); 83: #####: 75: while (win_ptr->current_lock_type != MPID_LOCK_NONE) 86: -: 76: { 87: -: 77: /* poke the progress engine */ 88: #####: 78: mpi_errno = MPID_Progress_wait(&progress_state); 1335: -: 840: 1336: -: 841: /* poke the progress engine */ 1337: #####: 842: MPID_Progress_start(&progress_state); 1338: #####: 843: while (win_ptr->current_lock_type != MPID_LOCK_NONE) 1340: branch 1 never executed 1341: -: 844: { 1342: #####: 845: mpi_errno = MPID_Progress_wait(&progress_state); 1511: -: 957: 1512: -: 958: /* poke the progress engine */ 1513: #####: 959: MPID_Progress_start(&progress_state); 1514: #####: 960: while (win_ptr->current_lock_type != MPID_LOCK_NONE) 1516: branch 1 never executed 1517: -: 961: { 1518: #####: 962: mpi_errno = MPID_Progress_wait(&progress_state); 2136: -: 1368: MPID_Progress_state progress_state; 2137: -: 1369: 2138: #####: 1370: MPID_Progress_start(&progress_state); 2139: #####: 1371: while (MPIDI_CH3I_Try_acquire_win_lock(win_ptr, lock_type) == 0) 2142: branch 2 never executed 2143: -: 1372: { 2144: #####: 1373: mpi_errno = MPID_Progress_wait(&progress_state); 2508: branch 0 taken 0% 2509: branch 1 taken 100% (fallthrough) 2510: #####: 1625: curr_ptr = curr_ptr->next; 2514: branch 1 taken 100% 2515: -: 1628: /* last operation is a get. no need to wait for rma done pkt */ 2516: #####: 1629: *wait_for_rma_done_pkt = 0; 2531: branch 0 taken 0% (fallthrough) 2532: branch 1 taken 100% 2533: #####: 1642: *wait_for_rma_done_pkt = 0; 2534: #####: 1643: *curr_ptr_ptr = curr_ptr->next; 2535: #####: 1644: tmp_ptr = curr_ptr; 2536: #####: 1645: while (curr_ptr->next != NULL) 2537: branch 0 never executed 2538: branch 1 never executed 2539: #####: 1646: curr_ptr = curr_ptr->next; 2540: #####: 1647: curr_ptr->next = tmp_ptr; 2541: #####: 1648: tmp_ptr->next = NULL; 2542: #####: 1649: break; 2836: -: 1848: } 2837: -: 1849: 2838: #####: 1850: else if (rma_op->type == MPIDI_RMA_ACCUMULATE) { 2839: branch 0 never executed 2840: branch 1 never executed 2841: #####: 1851: MPIDI_Pkt_init(lock_accum_unlock_pkt, MPIDI_CH3_PKT_LOCK_ACCUM_UNLOCK); 2842: #####: 1852: lock_accum_unlock_pkt->target_win_handle = 2843: -: 1853: win_ptr->all_win_handles[rma_op->target_rank]; 2844: #####: 1854: lock_accum_unlock_pkt->source_win_handle = win_ptr->handle; 2845: #####: 1855: lock_accum_unlock_pkt->lock_type = lock_type; 2846: -: 1856: 2847: #####: 1857: lock_accum_unlock_pkt->addr = 2849: -: 1859: win_ptr->disp_units[rma_op->target_rank] * rma_op->target_disp; 2850: -: 1860: 2851: #####: 1861: lock_accum_unlock_pkt->count = rma_op->target_count; 2852: #####: 1862: lock_accum_unlock_pkt->datatype = rma_op->target_datatype; 2853: #####: 1863: lock_accum_unlock_pkt->op = rma_op->op; 2854: -: 1864: 2855: #####: 1865: iov[0].MPID_IOV_BUF = (MPID_IOV_BUF_CAST) lock_accum_unlock_pkt; 2856: #####: 1866: iov[0].MPID_IOV_LEN = sizeof(*lock_accum_unlock_pkt); 2884: branch 1 taken 100% 2885: -: 1874: { 2886: #####: 1875: origin_dt_derived = 1; 2887: #####: 1876: MPID_Datatype_get_ptr(rma_op->origin_datatype, origin_dtp); 2929: -: 1902: /* derived datatype on origin */ 2930: -: 1903: 2931: #####: 1904: iovcnt = 1; 2932: -: 1905: 2933: #####: 1906: request = MPID_Request_create(); 2934: call 0 never executed 2935: #####: 1907: if (request == NULL) { 2940: -: 1909: } 2941: -: 1910: 2942: #####: 1911: MPIU_Object_set_ref(request, 2); 2943: #####: 1912: request->kind = MPID_REQUEST_SEND; 2944: -: 1913: 2945: #####: 1914: request->dev.datatype_ptr = origin_dtp; 2947: -: 1916: is freed. */ 2948: -: 1917: 2949: #####: 1918: request->dev.segment_ptr = MPID_Segment_alloc( ); 2950: call 0 never executed 2951: #####: 1919: MPIU_ERR_CHKANDJUMP1(request->dev.segment_ptr == NULL, mpi_errno, MPI_ERR_OTHER, "**nomem", "**nomem %s", "MPID_Segment_alloc"); 2954: call 2 never executed 2955: -: 1920: 2956: #####: 1921: MPID_Segment_init(rma_op->origin_addr, rma_op->origin_count, 2958: -: 1922: rma_op->origin_datatype, 2959: -: 1923: request->dev.segment_ptr, 0); 2960: #####: 1924: request->dev.segment_first = 0; 2961: #####: 1925: request->dev.segment_size = rma_op->origin_count * origin_type_size; 2962: -: 1926: 2963: #####: 1927: request->dev.OnFinal = 0; 2964: #####: 1928: request->dev.OnDataAvail = 0; 2965: -: 1929: 2966: #####: 1930: mpi_errno = vc->sendNoncontig_fn(vc, request, iov[0].MPID_IOV_BUF, iov[0].MPID_IOV_LEN); 2998: branch 0 taken 0% (fallthrough) 2999: branch 1 taken 100% 3000: #####: 1943: if (*(request->cc_ptr) != 0) 3004: -: 1945: MPID_Progress_state progress_state; 3005: -: 1946: 3006: #####: 1947: MPID_Progress_start(&progress_state); 3007: #####: 1948: while (*(request->cc_ptr) != 0) 3009: branch 1 never executed 3010: -: 1949: { 3011: #####: 1950: mpi_errno = MPID_Progress_wait(&progress_state); 3025: -: 1960: } 3026: -: 1961: 3027: #####: 1962: mpi_errno = request->status.MPI_ERROR; 3028: #####: 1963: if (mpi_errno != MPI_SUCCESS) { 3033: -: 1965: } 3034: -: 1966: 3035: #####: 1967: MPID_Request_release(request); 3119: branch 1 taken 100% 3120: -: 2024: { 3121: #####: 2025: MPID_Datatype_get_ptr(rreq->dev.datatype, dtp); 3125: branch 3 never executed 3126: call 4 never executed 3127: #####: 2026: rreq->dev.datatype_ptr = dtp; 3169: branch 1 taken 100% 3170: -: 2056: { 3171: #####: 2057: MPID_Request_release(sreq); 3276: branch 1 taken 100% 3277: -: 2129: { 3278: #####: 2130: MPID_Request_release(req); 3392: branch 0 taken 0% (fallthrough) 3393: branch 1 taken 100% 3394: #####: 2208: MPIDI_CH3U_Request_complete( req ); 3402: branch 7 never executed 3403: call 8 never executed 3404: #####: 2209: *buflen = sizeof(MPIDI_CH3_Pkt_t); 3405: #####: 2210: *rreqp = NULL; 3406: #####: 2211: goto fn_exit; 3431: branch 1 taken 100% 3432: -: 2229: { 3433: #####: 2230: mpi_errno = MPIDI_CH3_ReqHandler_PutAccumRespComplete(vc, req, &complete); 3438: call 2 never executed 3439: -: 2232: 3440: #####: 2233: if (complete) 3442: branch 1 never executed 3443: -: 2234: { 3444: #####: 2235: *rreqp = NULL; 3445: #####: 2236: goto fn_exit; 3480: -: 2261: { 3481: -: 2262: /* copy all of dtype_info and dataloop */ 3482: #####: 2263: MPIU_Memcpy(req->dev.dtype_info, data_buf, sizeof(MPIDI_RMA_dtype_info)); 3504: call 21 never executed 3505: call 22 never executed 3506: #####: 2264: MPIU_Memcpy(req->dev.dataloop, data_buf + sizeof(MPIDI_RMA_dtype_info), put_pkt->dataloop_size); 3531: call 24 never executed 3532: -: 2265: 3533: #####: 2266: *buflen = sizeof(MPIDI_CH3_Pkt_t) + sizeof(MPIDI_RMA_dtype_info) + put_pkt->dataloop_size; 3534: -: 2267: 3535: -: 2268: /* All dtype data has been received, call req handler */ 3536: #####: 2269: mpi_errno = MPIDI_CH3_ReqHandler_PutRespDerivedDTComplete(vc, req, &complete); 3537: call 0 never executed 3538: #####: 2270: MPIU_ERR_CHKANDJUMP1(mpi_errno, mpi_errno, MPI_ERR_OTHER, "**ch3|postrecv", 3541: call 2 never executed 3542: -: 2271: "**ch3|postrecv %s", "MPIDI_CH3_PKT_PUT"); 3543: #####: 2272: if (complete) 3545: branch 1 never executed 3546: -: 2273: { 3547: #####: 2274: *rreqp = NULL; 3548: #####: 2275: goto fn_exit; 3712: -: 2400: { 3713: -: 2401: /* copy all of dtype_info and dataloop */ 3714: #####: 2402: MPIU_Memcpy(req->dev.dtype_info, data_buf, sizeof(MPIDI_RMA_dtype_info)); 3736: call 21 never executed 3737: call 22 never executed 3738: #####: 2403: MPIU_Memcpy(req->dev.dataloop, data_buf + sizeof(MPIDI_RMA_dtype_info), get_pkt->dataloop_size); 3763: call 24 never executed 3764: -: 2404: 3765: #####: 2405: *buflen = sizeof(MPIDI_CH3_Pkt_t) + sizeof(MPIDI_RMA_dtype_info) + get_pkt->dataloop_size; 3766: -: 2406: 3767: -: 2407: /* All dtype data has been received, call req handler */ 3768: #####: 2408: mpi_errno = MPIDI_CH3_ReqHandler_GetRespDerivedDTComplete(vc, req, &complete); 3769: call 0 never executed 3770: #####: 2409: MPIU_ERR_CHKANDJUMP1(mpi_errno, mpi_errno, MPI_ERR_OTHER, "**ch3|postrecv", 3773: call 2 never executed 3774: -: 2410: "**ch3|postrecv %s", "MPIDI_CH3_PKT_GET"); 3775: #####: 2411: if (complete) 3776: branch 0 never executed 3777: branch 1 never executed 3778: #####: 2412: *rreqp = NULL; 3900: branch 0 taken 0% (fallthrough) 3901: branch 1 taken 100% 3902: #####: 2501: MPIDI_CH3U_Request_complete(req); 3910: branch 7 never executed 3911: call 8 never executed 3912: #####: 2502: *buflen = sizeof(MPIDI_CH3_Pkt_t); 3913: #####: 2503: *rreqp = NULL; 3937: branch 1 taken 100% 3938: -: 2520: { 3939: #####: 2521: mpi_errno = MPIDI_CH3_ReqHandler_PutAccumRespComplete(vc, req, &complete); 3943: branch 1 never executed 3944: call 2 never executed 3945: #####: 2523: if (complete) 3947: branch 1 never executed 3948: -: 2524: { 3949: #####: 2525: *rreqp = NULL; 3950: #####: 2526: goto fn_exit; 3983: -: 2549: { 3984: -: 2550: /* copy all of dtype_info and dataloop */ 3985: #####: 2551: MPIU_Memcpy(req->dev.dtype_info, data_buf, sizeof(MPIDI_RMA_dtype_info)); 4007: call 21 never executed 4008: call 22 never executed 4009: #####: 2552: MPIU_Memcpy(req->dev.dataloop, data_buf + sizeof(MPIDI_RMA_dtype_info), accum_pkt->dataloop_size); 4034: call 24 never executed 4035: -: 2553: 4036: #####: 2554: *buflen = sizeof(MPIDI_CH3_Pkt_t) + sizeof(MPIDI_RMA_dtype_info) + accum_pkt->dataloop_size; 4037: -: 2555: 4038: -: 2556: /* All dtype data has been received, call req handler */ 4039: #####: 2557: mpi_errno = MPIDI_CH3_ReqHandler_AccumRespDerivedDTComplete(vc, req, &complete); 4040: call 0 never executed 4041: #####: 2558: MPIU_ERR_CHKANDJUMP1(mpi_errno, mpi_errno, MPI_ERR_OTHER, "**ch3|postrecv", 4044: call 2 never executed 4045: -: 2559: "**ch3|postrecv %s", "MPIDI_CH3_ACCUMULATE"); 4046: #####: 2560: if (complete) 4048: branch 1 never executed 4049: -: 2561: { 4050: #####: 2562: *rreqp = NULL; 4051: #####: 2563: goto fn_exit; 4226: -: 2704: MPIDI_Win_lock_queue *curr_ptr, *prev_ptr, *new_ptr; 4227: -: 2705: 4228: #####: 2706: new_ptr = (MPIDI_Win_lock_queue *) MPIU_Malloc(sizeof(MPIDI_Win_lock_queue)); 4229: call 0 never executed 4230: #####: 2707: if (!new_ptr) { 4235: -: 2709: } 4236: -: 2710: 4237: #####: 2711: new_ptr->pt_single_op = (MPIDI_PT_single_op *) MPIU_Malloc(sizeof(MPIDI_PT_single_op)); 4238: call 0 never executed 4239: #####: 2712: if (new_ptr->pt_single_op == NULL) { 4246: -: 2716: /* FIXME: MT: The queuing may need to be done atomically. */ 4247: -: 2717: 4248: #####: 2718: curr_ptr = (MPIDI_Win_lock_queue *) win_ptr->lock_queue; 4249: #####: 2719: prev_ptr = curr_ptr; 4250: #####: 2720: while (curr_ptr != NULL) 4252: branch 1 never executed 4253: -: 2721: { 4254: #####: 2722: prev_ptr = curr_ptr; 4255: #####: 2723: curr_ptr = curr_ptr->next; 4256: -: 2724: } 4257: -: 2725: 4258: #####: 2726: if (prev_ptr != NULL) 4259: branch 0 never executed 4260: branch 1 never executed 4261: #####: 2727: prev_ptr->next = new_ptr; 4262: -: 2728: else 4263: #####: 2729: win_ptr->lock_queue = new_ptr; 4264: -: 2730: 4265: #####: 2731: new_ptr->next = NULL; 4266: #####: 2732: new_ptr->lock_type = lock_put_unlock_pkt->lock_type; 4267: #####: 2733: new_ptr->source_win_handle = lock_put_unlock_pkt->source_win_handle; 4268: #####: 2734: new_ptr->vc = vc; 4269: -: 2735: 4270: #####: 2736: new_ptr->pt_single_op->type = MPIDI_RMA_PUT; 4271: #####: 2737: new_ptr->pt_single_op->addr = lock_put_unlock_pkt->addr; 4272: #####: 2738: new_ptr->pt_single_op->count = lock_put_unlock_pkt->count; 4273: #####: 2739: new_ptr->pt_single_op->datatype = lock_put_unlock_pkt->datatype; 4274: -: 2740: /* allocate memory to receive the data */ 4275: #####: 2741: new_ptr->pt_single_op->data = MPIU_Malloc(req->dev.recv_data_sz); 4276: call 0 never executed 4277: #####: 2742: if (new_ptr->pt_single_op->data == NULL) { 4282: -: 2744: } 4283: -: 2745: 4284: #####: 2746: new_ptr->pt_single_op->data_recd = 0; 4285: -: 2747: 4286: #####: 2748: MPIDI_Request_set_type(req, MPIDI_REQUEST_TYPE_PT_SINGLE_PUT); 4287: #####: 2749: req->dev.OnDataAvail = MPIDI_CH3_ReqHandler_SinglePutAccumComplete; 4288: #####: 2750: req->dev.user_buf = new_ptr->pt_single_op->data; 4289: #####: 2751: req->dev.lock_queue_entry = new_ptr; 4293: branch 0 taken 0% (fallthrough) 4294: branch 1 taken 100% 4295: #####: 2755: *buflen = sizeof(MPIDI_CH3_Pkt_t); 4296: #####: 2756: MPIDI_CH3U_Request_complete(req); 4304: branch 7 never executed 4305: call 8 never executed 4306: #####: 2757: *rreqp = NULL; 4327: branch 1 taken 100% 4328: -: 2773: { 4329: #####: 2774: mpi_errno = fcn(vc, req, &complete); 4330: call 0 never executed 4331: #####: 2775: if (complete) 4333: branch 1 never executed 4334: -: 2776: { 4335: #####: 2777: *rreqp = NULL; 4443: -: 2863: /* FIXME: MT: This may need to be done atomically. */ 4444: -: 2864: 4445: #####: 2865: curr_ptr = (MPIDI_Win_lock_queue *) win_ptr->lock_queue; 4446: #####: 2866: prev_ptr = curr_ptr; 4447: #####: 2867: while (curr_ptr != NULL) 4449: branch 1 never executed 4450: -: 2868: { 4451: #####: 2869: prev_ptr = curr_ptr; 4452: #####: 2870: curr_ptr = curr_ptr->next; 4453: -: 2871: } 4454: -: 2872: 4455: #####: 2873: new_ptr = (MPIDI_Win_lock_queue *) MPIU_Malloc(sizeof(MPIDI_Win_lock_queue)); 4456: call 0 never executed 4457: #####: 2874: if (!new_ptr) { 4461: call 0 never executed 4462: -: 2876: } 4463: #####: 2877: new_ptr->pt_single_op = (MPIDI_PT_single_op *) MPIU_Malloc(sizeof(MPIDI_PT_single_op)); 4464: call 0 never executed 4465: #####: 2878: if (new_ptr->pt_single_op == NULL) { 4470: -: 2880: } 4471: -: 2881: 4472: #####: 2882: if (prev_ptr != NULL) 4473: branch 0 never executed 4474: branch 1 never executed 4475: #####: 2883: prev_ptr->next = new_ptr; 4476: -: 2884: else 4477: #####: 2885: win_ptr->lock_queue = new_ptr; 4478: -: 2886: 4479: #####: 2887: new_ptr->next = NULL; 4480: #####: 2888: new_ptr->lock_type = lock_get_unlock_pkt->lock_type; 4481: #####: 2889: new_ptr->source_win_handle = lock_get_unlock_pkt->source_win_handle; 4482: #####: 2890: new_ptr->vc = vc; 4483: -: 2891: 4484: #####: 2892: new_ptr->pt_single_op->type = MPIDI_RMA_GET; 4485: #####: 2893: new_ptr->pt_single_op->addr = lock_get_unlock_pkt->addr; 4486: #####: 2894: new_ptr->pt_single_op->count = lock_get_unlock_pkt->count; 4487: #####: 2895: new_ptr->pt_single_op->datatype = lock_get_unlock_pkt->datatype; 4488: #####: 2896: new_ptr->pt_single_op->data = NULL; 4489: #####: 2897: new_ptr->pt_single_op->request_handle = lock_get_unlock_pkt->request_handle; 4490: #####: 2898: new_ptr->pt_single_op->data_recd = 1; 4506: -: 2914: MPIDI_msg_sz_t *buflen, MPID_Request **rreqp ) 4507: function MPIDI_CH3_PktHandler_LockAccumUnlock called 0 returned 0% blocks executed 0% 4508: #####: 2915:{ 4509: -: 2916: MPIDI_CH3_Pkt_lock_accum_unlock_t * lock_accum_unlock_pkt = 4510: #####: 2917: &pkt->lock_accum_unlock; 4511: #####: 2918: MPID_Request *req = NULL; 4512: #####: 2919: MPID_Win *win_ptr = NULL; 4513: #####: 2920: MPIDI_Win_lock_queue *curr_ptr = NULL, *prev_ptr = NULL, *new_ptr = NULL; 4514: -: 2921: int type_size; 4515: -: 2922: int complete; 4516: #####: 2923: char *data_buf = NULL; 4517: -: 2924: MPIDI_msg_sz_t data_len; 4518: #####: 2925: int mpi_errno = MPI_SUCCESS; 4526: -: 2933: data into a temporary buffer first */ 4527: -: 2934: 4528: #####: 2935: data_len = *buflen - sizeof(MPIDI_CH3_Pkt_t); 4529: #####: 2936: data_buf = (char *)pkt + sizeof(MPIDI_CH3_Pkt_t); 4530: -: 2937: 4531: #####: 2938: req = MPID_Request_create(); 4532: call 0 never executed 4533: #####: 2939: MPIU_Object_set_ref(req, 1); 4534: -: 2940: 4535: #####: 2941: req->dev.datatype = lock_accum_unlock_pkt->datatype; 4536: #####: 2942: MPID_Datatype_get_size_macro(lock_accum_unlock_pkt->datatype, type_size); 4540: branch 3 never executed 4541: call 4 never executed 4542: #####: 2943: req->dev.recv_data_sz = type_size * lock_accum_unlock_pkt->count; 4543: #####: 2944: req->dev.user_count = lock_accum_unlock_pkt->count; 4544: #####: 2945: req->dev.target_win_handle = lock_accum_unlock_pkt->target_win_handle; 4546: -: 2947: /* queue the information */ 4547: -: 2948: 4548: #####: 2949: new_ptr = (MPIDI_Win_lock_queue *) MPIU_Malloc(sizeof(MPIDI_Win_lock_queue)); 4549: call 0 never executed 4550: #####: 2950: if (!new_ptr) { 4555: -: 2952: } 4556: -: 2953: 4557: #####: 2954: new_ptr->pt_single_op = (MPIDI_PT_single_op *) MPIU_Malloc(sizeof(MPIDI_PT_single_op)); 4558: call 0 never executed 4559: #####: 2955: if (new_ptr->pt_single_op == NULL) { 4564: -: 2957: } 4565: -: 2958: 4566: #####: 2959: MPID_Win_get_ptr(lock_accum_unlock_pkt->target_win_handle, win_ptr); 4572: -: 2961: /* FIXME: MT: The queuing may need to be done atomically. */ 4573: -: 2962: 4574: #####: 2963: curr_ptr = (MPIDI_Win_lock_queue *) win_ptr->lock_queue; 4575: #####: 2964: prev_ptr = curr_ptr; 4576: #####: 2965: while (curr_ptr != NULL) 4578: branch 1 never executed 4579: -: 2966: { 4580: #####: 2967: prev_ptr = curr_ptr; 4581: #####: 2968: curr_ptr = curr_ptr->next; 4582: -: 2969: } 4583: -: 2970: 4584: #####: 2971: if (prev_ptr != NULL) 4585: branch 0 never executed 4586: branch 1 never executed 4587: #####: 2972: prev_ptr->next = new_ptr; 4588: -: 2973: else 4589: #####: 2974: win_ptr->lock_queue = new_ptr; 4590: -: 2975: 4591: #####: 2976: new_ptr->next = NULL; 4592: #####: 2977: new_ptr->lock_type = lock_accum_unlock_pkt->lock_type; 4593: #####: 2978: new_ptr->source_win_handle = lock_accum_unlock_pkt->source_win_handle; 4594: #####: 2979: new_ptr->vc = vc; 4595: -: 2980: 4596: #####: 2981: new_ptr->pt_single_op->type = MPIDI_RMA_ACCUMULATE; 4597: #####: 2982: new_ptr->pt_single_op->addr = lock_accum_unlock_pkt->addr; 4598: #####: 2983: new_ptr->pt_single_op->count = lock_accum_unlock_pkt->count; 4599: #####: 2984: new_ptr->pt_single_op->datatype = lock_accum_unlock_pkt->datatype; 4600: #####: 2985: new_ptr->pt_single_op->op = lock_accum_unlock_pkt->op; 4601: -: 2986: /* allocate memory to receive the data */ 4602: #####: 2987: new_ptr->pt_single_op->data = MPIU_Malloc(req->dev.recv_data_sz); 4603: call 0 never executed 4604: #####: 2988: if (new_ptr->pt_single_op->data == NULL) { 4609: -: 2990: } 4610: -: 2991: 4611: #####: 2992: new_ptr->pt_single_op->data_recd = 0; 4612: -: 2993: 4613: #####: 2994: MPIDI_Request_set_type(req, MPIDI_REQUEST_TYPE_PT_SINGLE_ACCUM); 4614: #####: 2995: req->dev.user_buf = new_ptr->pt_single_op->data; 4615: #####: 2996: req->dev.lock_queue_entry = new_ptr; 4616: -: 2997: 4617: #####: 2998: *rreqp = req; 4618: #####: 2999: if (req->dev.recv_data_sz == 0) { 4619: branch 0 never executed 4620: branch 1 never executed 4621: #####: 3000: *buflen = sizeof(MPIDI_CH3_Pkt_t); 4622: #####: 3001: MPIDI_CH3U_Request_complete(req); 4630: branch 7 never executed 4631: call 8 never executed 4632: #####: 3002: *rreqp = NULL; 4633: -: 3003: } 4634: -: 3004: else { 4635: #####: 3005: mpi_errno = MPIDI_CH3U_Receive_data_found(req, data_buf, &data_len, 4639: -: 3008: post_data_receive reset the handler. There should 4640: -: 3009: be a cleaner way to do this */ 4641: #####: 3010: if (!req->dev.OnDataAvail) { 4642: branch 0 never executed 4643: branch 1 never executed 4644: #####: 3011: req->dev.OnDataAvail = MPIDI_CH3_ReqHandler_SinglePutAccumComplete; 4645: -: 3012: } 4646: #####: 3013: if (mpi_errno != MPI_SUCCESS) { 4652: -: 3016: } 4653: -: 3017: /* return the number of bytes processed in this function */ 4654: #####: 3018: *buflen = data_len + sizeof(MPIDI_CH3_Pkt_t); 4655: -: 3019: 4656: #####: 3020: if (complete) 4658: branch 1 never executed 4659: -: 3021: { 4660: #####: 3022: mpi_errno = MPIDI_CH3_ReqHandler_SinglePutAccumComplete(vc, req, &complete); 4661: call 0 never executed 4662: #####: 3023: if (complete) 4664: branch 1 never executed 4665: -: 3024: { 4666: #####: 3025: *rreqp = NULL; 4670: -: 3027: } 4671: -: 3028: } 4672: #####: 3031: return mpi_errno; 4718: branch 0 taken 0% (fallthrough) 4719: branch 1 taken 100% 4720: #####: 3067: MPIDI_CH3U_Request_complete( req ); 4728: branch 7 never executed 4729: call 8 never executed 4730: #####: 3068: *buflen = sizeof(MPIDI_CH3_Pkt_t); 4731: #####: 3069: *rreqp = NULL; 4744: branch 1 taken 100% 4745: -: 3077: { 4746: #####: 3078: MPIDI_CH3U_Request_complete(req); 4754: branch 7 never executed 4755: call 8 never executed 4756: #####: 3079: *rreqp = NULL; 218 line(s) not covered by tests in src/mpid/ch3/src/ch3u_rma_sync.c.gcov Uncovered lines in src/mpid/ch3/src/ch3u_rndv.c.gcov 86: branch 1 taken 100% 87: -: 70: { 88: #####: 71: MPIU_Object_set_ref(sreq, 0); 89: #####: 72: MPIDI_CH3_Request_destroy(sreq); 90: call 0 never executed 91: #####: 73: *sreq_p = NULL; 92: #####: 73: *sreq_p = NULL; 93: call 0 never executed 94: #####: 75: MPID_Request_release(rts_sreq); 284: branch 1 taken 100% 285: -: 224: { 286: #####: 225: MPID_Request_release(rts_sreq); 392: branch 0 taken 0% (fallthrough) 393: branch 1 taken 100% 394: #####: 297: *buflen = sizeof(MPIDI_CH3_Pkt_t); 395: #####: 298: MPIDI_CH3U_Request_complete(req); 403: branch 7 never executed 404: call 8 never executed 405: #####: 299: *rreqp = NULL; 423: branch 1 taken 100% 424: -: 312: { 425: #####: 313: MPIDI_CH3U_Request_complete(req); 433: branch 7 never executed 434: call 8 never executed 435: #####: 314: *rreqp = NULL; 10 line(s) not covered by tests in src/mpid/ch3/src/ch3u_rndv.c.gcov Uncovered lines in src/mpid/ch3/src/ch3u_eager.c.gcov 164: 381410: 135: fn_exit: 165: 381410: 136: return mpi_errno; 166: #####: 138: *sreq_p = NULL; 167: #####: 139: goto fn_exit; 758: branch 1 taken 100% 759: -: 622: { 760: #####: 623: MPIDI_CH3U_Request_complete(rreq); 768: branch 7 never executed 769: call 8 never executed 770: #####: 624: *rreqp = NULL; 863: branch 1 taken 100% 864: -: 693: { 865: #####: 694: MPIDI_CH3U_Request_complete(rreq); 873: branch 7 never executed 874: call 8 never executed 875: #####: 695: *rreqp = NULL; 899: -: 718: ready_pkt->match.parts.rank, 900: -: 719: ready_pkt->match.parts.tag); 901: #####: 720: rreq->status.count = 0; 902: #####: 721: if (rreq->dev.recv_data_sz > 0) 905: -: 722: { 906: -: 723: /* force read of extra data */ 907: #####: 724: *rreqp = rreq; 908: #####: 725: rreq->dev.segment_first = 0; 909: #####: 726: rreq->dev.segment_size = 0; 910: #####: 727: mpi_errno = MPIDI_CH3U_Request_load_recv_iov(rreq); 911: call 0 never executed 912: #####: 728: if (mpi_errno != MPI_SUCCESS) { 921: -: 734: { 922: -: 735: /* mark data transfer as complete and decrement CC */ 923: #####: 736: MPIDI_CH3U_Request_complete(rreq); 931: branch 7 never executed 932: call 8 never executed 933: #####: 737: *rreqp = NULL; 934: -: 738: } 935: -: 739: /* we didn't process anything but the header in this case */ 936: #####: 740: *buflen = sizeof(MPIDI_CH3_Pkt_t); 16 line(s) not covered by tests in src/mpid/ch3/src/ch3u_eager.c.gcov Uncovered lines in src/mpid/ch3/src/ch3u_eagersync.c.gcov 132: 3949: 107: fn_exit: 133: 3949: 108: return mpi_errno; 134: #####: 110: *sreq_p = NULL; 135: #####: 111: goto fn_exit; 333: branch 1 taken 100% 334: -: 263: { 335: #####: 264: MPIDI_CH3U_Request_complete(rreq); 343: branch 7 never executed 344: call 8 never executed 345: #####: 265: *rreqp = NULL; 416: branch 1 taken 100% 417: -: 307: { 418: #####: 308: MPIDI_CH3U_Request_complete(rreq); 426: branch 7 never executed 427: call 8 never executed 428: #####: 309: *rreqp = NULL; 6 line(s) not covered by tests in src/mpid/ch3/src/ch3u_eagersync.c.gcov Uncovered lines in src/mpid/ch3/src/mpid_abort.c.gcov 55: branch 1 taken 100% 56: -: 48: /* Create a default error message */ 57: #####: 49: error_msg = error_str; 60: -: 52: communicator, so using other than the rank in comm world does not 61: -: 53: identify the process, as the message suggests */ 62: #####: 54: if (comm) 64: branch 1 never executed 65: -: 55: { 66: #####: 56: rank = comm->rank; 68: -: 58: else 69: -: 59: { 70: #####: 60: if (MPIR_Process.comm_world != NULL) 72: branch 1 never executed 73: -: 61: { 74: #####: 62: rank = MPIR_Process.comm_world->rank; 76: -: 64: else 77: -: 65: { 78: #####: 66: rank = -1; 80: -: 68: } 81: -: 69: 82: #####: 70: if (mpi_errno != MPI_SUCCESS) 84: branch 1 never executed 85: -: 71: { 86: #####: 72: MPIR_Err_get_string(mpi_errno, msg, MPI_MAX_ERROR_STRING, NULL); 87: call 0 never executed 88: -: 73: /* FIXME: Not internationalized */ 89: #####: 74: MPIU_Snprintf(error_str, sizeof(error_str), "internal ABORT - process %d: %s", rank, msg); 93: -: 77: { 94: -: 78: /* FIXME: Not internationalized */ 95: #####: 79: MPIU_Snprintf(error_str, sizeof(error_str), "internal ABORT - process %d", rank); 120: -: 101: /* ch3_abort should not return but if it does, exit here. If it does, 121: -: 102: add the function exit code before calling the final exit. */ 122: #####: 104: MPIU_Exit(exit_code); 123: call 0 never executed 124: -: 105: 125: #####: 106: return MPI_ERR_INTERN; 163: -: 140: 164: -: 141: /* if abort returns for some reason, exit here */ 165: #####: 142: exit(exit_code); 13 line(s) not covered by tests in src/mpid/ch3/src/mpid_abort.c.gcov All code covered by tests in src/mpid/ch3/src/mpid_cancel_recv.c.gcov Uncovered lines in src/mpid/ch3/src/mpid_cancel_send.c.gcov 42: branch 1 taken 100% 43: -: 31: { 44: #####: 32: goto fn_exit; 57: branch 1 taken 100% 58: -: 44: { 59: #####: 45: goto fn_exit; 76: -: 58: 77: -: 59: MPIU_THREAD_CS_ENTER(MSGQUEUE,); 78: #####: 60: rreq = MPIDI_CH3U_Recvq_FDU(sreq->handle, &sreq->dev.match); 79: call 0 never executed 80: -: 61: MPIU_THREAD_CS_EXIT(MSGQUEUE,); 81: #####: 62: if (rreq) 83: branch 1 never executed 84: -: 63: { 85: #####: 64: MPIU_Assert(rreq->partner_request == sreq); 93: -: 68: sreq->handle, rreq->handle)); 94: -: 69: 95: #####: 70: MPIU_Object_set_ref(rreq, 0); 96: #####: 71: MPIDI_CH3_Request_destroy(rreq); 97: call 0 never executed 98: -: 72: 99: #####: 73: sreq->status.cancelled = TRUE; 100: -: 74: /* no other thread should be waiting on sreq, so it is safe to 101: -: 75: reset ref_count and cc */ 102: #####: 76: sreq->cc = 0; 103: #####: 77: MPIU_Object_set_ref(sreq, 1); 105: -: 79: else 106: -: 80: { 107: #####: 81: sreq->status.cancelled = FALSE; 138: branch 1 taken 100% 139: -: 109: { 140: #####: 110: cancelled = FALSE; 142: -: 112: /* since we attempted to cancel a RTS request, then we are 143: -: 113: responsible for releasing that request */ 144: #####: 114: MPID_Request_release(rts_sreq); 163: -: 115: 164: -: 124: 165: #####: 125: if (cancelled) 167: branch 1 never executed 168: -: 126: { 169: #####: 127: sreq->status.cancelled = TRUE; 170: -: 128: /* no other thread should be waiting on sreq, so it is 171: -: 129: safe to reset ref_count and cc */ 172: #####: 130: sreq->cc = 0; 173: #####: 131: MPIU_Object_set_ref(sreq, 1); 174: #####: 132: goto fn_exit; 183: branch 1 taken 100% 184: -: 140: { 185: #####: 141: sreq->status.cancelled = TRUE; 186: -: 142: /* no other thread should be waiting on sreq, so it is safe to 187: -: 143: reset ref_count and cc */ 188: #####: 144: sreq->cc = 0; 189: #####: 145: MPIU_Object_set_ref(sreq, 1); 190: #####: 146: goto fn_exit; 22 line(s) not covered by tests in src/mpid/ch3/src/mpid_cancel_send.c.gcov All code covered by tests in src/mpid/ch3/src/mpid_comm_disconnect.c.gcov All code covered by tests in src/mpid/ch3/src/mpid_comm_spawn_multiple.c.gcov All code covered by tests in src/mpid/ch3/src/mpid_finalize.c.gcov Uncovered lines in src/mpid/ch3/src/mpid_get_universe_size.c.gcov 65: branch 1 taken 100% 66: -: 54: { 67: #####: 55: *universe_size = MPIR_UNIVERSE_SIZE_NOT_AVAILABLE; 1 line(s) not covered by tests in src/mpid/ch3/src/mpid_get_universe_size.c.gcov All code covered by tests in src/mpid/ch3/src/mpid_getpname.c.gcov Uncovered lines in src/mpid/ch3/src/mpid_init.c.gcov 79: branch 2 never executed 80: branch 3 never executed 81: #####: 70: MPIDI_Use_pmi2_api = TRUE; 552: -: 441: else { 553: -: 442: /* Create a default pg id */ 554: #####: 443: pg_id = MPIU_Malloc(2); 555: call 0 never executed 556: #####: 444: if (pg_id == NULL) { 560: call 0 never executed 561: -: 446: } 562: #####: 447: MPIU_Strncpy( pg_id, "0", 2 ); 4 line(s) not covered by tests in src/mpid/ch3/src/mpid_init.c.gcov All code covered by tests in src/mpid/ch3/src/mpid_iprobe.c.gcov Uncovered lines in src/mpid/ch3/src/mpid_irecv.c.gcov 177: branch 1 taken 100% 178: -: 121: { 179: #####: 122: MPID_Datatype_get_ptr(datatype, rreq->dev.datatype_ptr); 183: branch 3 never executed 184: call 4 never executed 185: #####: 123: MPID_Datatype_add_ref(rreq->dev.datatype_ptr); 2 line(s) not covered by tests in src/mpid/ch3/src/mpid_irecv.c.gcov Uncovered lines in src/mpid/ch3/src/mpid_irsend.c.gcov 71: branch 1 taken 100% 72: -: 52: { 73: #####: 53: MPIU_Object_set_ref(sreq, 1); 74: #####: 54: sreq->cc = 0; 75: #####: 55: goto fn_exit; 110: -: 79: MPIU_DBG_MSG(CH3_OTHER,VERBOSE,"sending zero length message"); 111: -: 80: 112: #####: 81: sreq->dev.OnDataAvail = 0; 117: -: 86: 118: -: 87: MPIU_THREAD_CS_ENTER(CH3COMM,vc); 119: #####: 88: mpi_errno = MPIU_CALL(MPIDI_CH3,iSend(vc, sreq, ready_pkt, sizeof(*ready_pkt))); 161: branch 2 taken 0% (fallthrough) 162: branch 3 taken 100% 163: #####: 119: sreq->dev.datatype_ptr = dt_ptr; 164: #####: 120: MPID_Datatype_add_ref(dt_ptr); 7 line(s) not covered by tests in src/mpid/ch3/src/mpid_irsend.c.gcov Uncovered lines in src/mpid/ch3/src/mpid_isend.c.gcov 192: branch 2 taken 0% (fallthrough) 193: branch 3 taken 100% 194: #####: 146: sreq->dev.datatype_ptr = dt_ptr; 195: #####: 147: MPID_Datatype_add_ref(dt_ptr); 219: branch 1 taken 100% 220: -: 165: { 221: #####: 166: sreq->dev.datatype_ptr = dt_ptr; 222: #####: 167: MPID_Datatype_add_ref(dt_ptr); 4 line(s) not covered by tests in src/mpid/ch3/src/mpid_isend.c.gcov Uncovered lines in src/mpid/ch3/src/mpid_issend.c.gcov 86: branch 1 taken 100% 87: -: 63: { 88: #####: 64: MPIU_Object_set_ref(sreq, 1); 89: #####: 65: sreq->cc = 0; 90: #####: 66: goto fn_exit; 104: branch 1 taken 100% 105: -: 72: { 106: #####: 73: mpi_errno = MPIDI_CH3_EagerSyncZero( &sreq, rank, tag, comm, 107: call 0 never executed 108: -: 74: context_offset ); 109: #####: 75: goto fn_exit; 126: branch 2 taken 0% (fallthrough) 127: branch 3 taken 100% 128: #####: 87: sreq->dev.datatype_ptr = dt_ptr; 129: #####: 88: MPID_Datatype_add_ref(dt_ptr); 153: branch 1 taken 100% 154: -: 106: { 155: #####: 107: sreq->dev.datatype_ptr = dt_ptr; 156: #####: 108: MPID_Datatype_add_ref(dt_ptr); 9 line(s) not covered by tests in src/mpid/ch3/src/mpid_issend.c.gcov Uncovered lines in src/mpid/ch3/src/mpid_port.c.gcov 122: branch 0 taken 0% (fallthrough) 123: branch 1 taken 100% 124: #####: 105: MPIU_CALL(MPIDI_CH3,PortFnsInit( &portFns )); 125: call 0 never executed 126: #####: 106: setupPortFunctions = 0; 320: -: 259: 321: -: 261: /* Everything is used up */ 322: #####: 262: *port_name_tag = -1; 323: #####: 263: mpi_errno = MPI_ERR_OTHER; 324: #####: 264: goto fn_exit; 371: branch 0 taken 0% (fallthrough) 372: branch 1 taken 100% 373: #####: 304: mpi_errno = MPI_SUCCESS; 444: branch 1 taken 100% 445: -: 364: { 446: #####: 365: mpi_errno = MPI_SUCCESS; 7 line(s) not covered by tests in src/mpid/ch3/src/mpid_port.c.gcov All code covered by tests in src/mpid/ch3/src/mpid_probe.c.gcov All code covered by tests in src/mpid/ch3/src/mpid_recv.c.gcov Uncovered lines in src/mpid/ch3/src/mpid_rsend.c.gcov 125: -: 95: { 126: -: 96: MPIDI_Request_set_seqnum(sreq, seqnum); 127: #####: 97: MPIDI_Request_set_type(sreq, MPIDI_REQUEST_TYPE_RSEND); 1 line(s) not covered by tests in src/mpid/ch3/src/mpid_rsend.c.gcov All code covered by tests in src/mpid/ch3/src/mpid_send.c.gcov All code covered by tests in src/mpid/ch3/src/mpid_ssend.c.gcov Uncovered lines in src/mpid/ch3/src/mpid_startall.c.gcov 221: branch 1 taken 100% 222: -: 184: { 223: #####: 185: MPID_Datatype_get_ptr(datatype, sreq->dev.datatype_ptr); 227: branch 3 never executed 228: call 4 never executed 229: #####: 186: MPID_Datatype_add_ref(sreq->dev.datatype_ptr); 270: branch 1 taken 100% 271: -: 214: { 272: #####: 215: MPID_Datatype_get_ptr(datatype, sreq->dev.datatype_ptr); 276: branch 3 never executed 277: call 4 never executed 278: #####: 216: MPID_Datatype_add_ref(sreq->dev.datatype_ptr); 368: branch 1 taken 100% 369: -: 274: { 370: #####: 275: MPID_Datatype_get_ptr(datatype, sreq->dev.datatype_ptr); 374: branch 3 never executed 375: call 4 never executed 376: #####: 276: MPID_Datatype_add_ref(sreq->dev.datatype_ptr); 422: branch 1 taken 100% 423: -: 311: { 424: #####: 315: goto fn_exit; 7 line(s) not covered by tests in src/mpid/ch3/src/mpid_startall.c.gcov Uncovered lines in src/mpid/ch3/src/mpid_vc.c.gcov 104: 960040: 86: MPIU_CHKPMEM_COMMIT(); 105: 960040: 88: return mpi_errno; 106: #####: 90: MPIU_CHKPMEM_REAP(); 240: -: 186: vc->pg_rank == MPIDI_Process.my_pg_rank) 241: -: 187: { 242: #####: 188: MPIDI_PG_release_ref(vc->pg, &inuse); 245: call 2 never executed 246: call 3 never executed 247: #####: 189: if (inuse == 0) 249: branch 1 never executed 250: -: 190: { 251: #####: 191: MPIDI_PG_Destroy(vc->pg); 276: branch 1 taken 100% 277: -: 207: { 278: #####: 208: MPIDI_PG_Destroy(vc->pg); 456: branch 0 taken 0% (fallthrough) 457: branch 1 taken 100% 458: #####: 351: *singlePG = 0; 521: branch 1 taken 100% 522: -: 406: /* Internal error. This gpid is unknown on this process */ 523: #####: 407: printf("No matching pg foung for id = %d\n", pgid ); 524: call 0 never executed 525: #####: 408: lpid[i] = -1; 527: call 0 never executed 528: -: 410: "**unknowngpid %d %d", gpid[0], gpid[1] ); 529: #####: 411: return mpi_errno; 544: -: 421: } 545: -: 422: else { 546: #####: 423: lpid[i] = -1; 548: call 0 never executed 549: -: 425: "**unknowngpid %d %d", gpid[0], gpid[1] ); 550: #####: 426: return mpi_errno; 757: -: 594:static int MPIDI_CH3U_VC_FinishPending( MPIDI_VCRT_t *vcrt ) 758: function MPIDI_CH3U_VC_FinishPending called 0 returned 0% blocks executed 0% 759: #####: 595:{ 760: #####: 596: int mpi_errno = MPI_SUCCESS; 770: -: 606: A virtual connection has pending operations if the state 771: -: 607: is not INACTIVE or if the sendq is not null */ 772: #####: 608: nPending = 0; 773: #####: 609: vc = vcrt->vcr_table; 774: #####: 610: size = vcrt->size; 775: -: 611: /* printf( "Size = %d\n", size ); fflush(stdout); */ 776: #####: 612: for (i=0; istate != MPIDI_VC_STATE_INACTIVE) { 781: branch 1 never executed 782: -: 614: /* FIXME: Printf for debugging */ 783: #####: 615: printf ("state for vc[%d] is %d\n", 784: call 0 never executed 785: #####: 616: i, vc[i]->state ); fflush(stdout); 786: call 0 never executed 787: #####: 617: nPending++; 799: -: 629:#endif 800: -: 630: } 801: #####: 631: if (nPending > 0) { 802: branch 0 never executed 803: branch 1 never executed 804: #####: 632: printf( "Panic! %d pending operations!\n", nPending ); 805: call 0 never executed 806: #####: 633: fflush(stdout); 807: call 0 never executed 808: #####: 634: MPIU_Assert( nPending == 0 ); 813: -: 635: } 814: -: 636: else { 815: #####: 637: break; 816: -: 638: } 817: -: 639: 818: #####: 640: MPID_Progress_start(&progress_state); 820: -: 642: "Waiting for %d close operations", 821: -: 643: nPending); 822: #####: 644: mpi_errno = MPID_Progress_wait(&progress_state); 833: call 0 never executed 834: -: 652: MPID_Progress_end(&progress_state); 835: #####: 653: } while(nPending > 0); 837: branch 1 never executed 838: -: 654: 839: #####: 655: fn_exit: 840: #####: 655: fn_exit: 841: #####: 657: return mpi_errno; 860: -: 676:int MPIDI_CH3U_Comm_FinishPending( MPID_Comm *comm_ptr ) 861: function MPIDI_CH3U_Comm_FinishPending called 0 returned 0% blocks executed 0% 862: #####: 677:{ 863: #####: 678: int mpi_errno = MPI_SUCCESS; 866: -: 681: MPIDI_FUNC_ENTER(MPID_STATE_MPIDI_CH3U_COMM_FINISHPENDING); 867: -: 682: 868: #####: 683: mpi_errno = MPIDI_CH3U_VC_FinishPending( comm_ptr->vcrt ); 869: call 0 never executed 870: #####: 684: if (!mpi_errno && comm_ptr->local_vcrt) { 873: branch 2 never executed 874: branch 3 never executed 875: #####: 685: mpi_errno = MPIDI_CH3U_VC_FinishPending( comm_ptr->local_vcrt ); 878: -: 686: } 879: -: 687: 880: #####: 689: return mpi_errno; 1113: -: 866: * process layout on the part of the process manager. Consider this a 1114: -: 867: * non-fatal error case. */ 1115: #####: 868: *type = NULL_MAPPING; 1116: #####: 869: *map = NULL; 1117: #####: 870: *nblocks = 0; 1118: #####: 871: goto fn_exit; 1119: -: 872: } 1120: -: 873: 1121: #####: 874: skip_space(c); 1146: 2818: 880: *type = VECTOR_MAPPING; 1147: -: 881: else 1148: #####: 882: parse_error(); 1204: branch 1 taken 0% (fallthrough) 1205: branch 2 taken 100% 1206: #####: 905: parse_error(); 1226: branch 1 taken 0% (fallthrough) 1227: branch 2 taken 100% 1228: #####: 913: parse_error(); 1248: branch 1 taken 0% (fallthrough) 1249: branch 2 taken 100% 1250: #####: 921: parse_error(); 1274: 2818: 932:fn_exit: 1275: 2818: 934: return mpi_errno; 1276: #####: 936: MPIU_CHKPMEM_REAP(); 1388: branch 0 taken 0% (fallthrough) 1389: branch 1 taken 100% 1390: #####: 1029: *num_nodes = node_id; 1400: 2818: 1035: goto fn_exit; 1401: -: 1036: } 1402: #####: 1037: ++node_id; 1411: call 0 returned 100% 1412: 2818: 1045: return mpi_errno; 1413: #####: 1047: *did_map = 0; 1414: #####: 1048: goto fn_exit; 1480: branch 2 never executed 1481: branch 3 never executed 1482: #####: 1106: no_local = 1; 1496: branch 2 never executed 1497: branch 3 never executed 1498: #####: 1117: odd_even_cliques = 1; 1503: branch 1 taken 100% 1504: -: 1121: /* just assign 0 to n-1 as node ids and bail */ 1505: #####: 1122: for (i = 0; i < pg->size; ++i) { 1506: branch 0 never executed 1507: branch 1 never executed 1508: #####: 1123: pg->vct[i].node_id = g_num_nodes++; 1563: -: 1176: /* FIXME this routine can't handle the dynamic process case at this 1564: -: 1177: time. This will require more support from the process manager. */ 1565: #####: 1178: MPIU_Assert(0); 1746: -: 1266: may leave nodes ids with no processes assigned to them, but 1747: -: 1267: I think this is OK */ 1748: #####: 1268: for (i = 0; i < pg->size; ++i) 1749: branch 0 never executed 1750: branch 1 never executed 1751: #####: 1269: if (i & 0x1) 1752: branch 0 never executed 1753: branch 1 never executed 1754: #####: 1270: pg->vct[i].node_id += g_num_nodes; 1755: #####: 1271: g_num_nodes *= 2; 60 line(s) not covered by tests in src/mpid/ch3/src/mpid_vc.c.gcov All code covered by tests in src/mpid/ch3/src/mpid_rma.c.gcov All code covered by tests in src/mpid/ch3/src/mpidi_isend_self.c.gcov Uncovered lines in src/mpid/ch3/src/mpidi_pg.c.gcov 80: branch 22 never executed 81: branch 23 never executed 82: #####: 51: verbose = 1; 105: branch 10 taken 100% 106: -: 58: int j; 107: #####: 59: verbose = 1; 108: #####: 60: for (j=i; jnext; 461: -: 331: } 462: -: 332: else { 463: #####: 333: MPIU_Free(pg->connData); 562: -: 417:int MPIDI_PG_Has_next(MPIDI_PG_iterator *iter) 563: function MPIDI_PG_Has_next called 0 returned 0% blocks executed 0% 564: #####: 418:{ 565: #####: 419: return (*iter != NULL); 910: branch 0 taken 0% (fallthrough) 911: branch 1 taken 100% 912: #####: 711: MPIDI_PG_CheckForSingleton(); 913: call 0 never executed 914: #####: 712: pmi_errno = PMI_KVS_Get(pg->connData, key, buf, bufsize ); 971: branch 0 taken 0% (fallthrough) 972: branch 1 taken 100% 973: #####: 755: MPIU_Internal_error_printf( 1005: branch 0 taken 0% (fallthrough) 1006: branch 1 taken 100% 1007: #####: 782: char *nstring = 0; 1008: #####: 783: curSlen += (pg->size - i) * (vallen + 1 ); 1009: #####: 784: nstring = MPIU_Realloc( string, curSlen); 1010: call 0 never executed 1011: #####: 785: if (!nstring) { 1015: call 0 never executed 1016: -: 787: } 1017: #####: 788: string = nstring; 1036: 1072: 800: fn_exit: 1037: 1072: 801: return mpi_errno; 1038: #####: 803: if (string) MPIU_Free(string); 1045: -: 807: MPIDI_PG_t *pg ATTRIBUTE((unused)) ) 1046: function connFromStringKVS called 0 returned 0% blocks executed 0% 1047: #####: 808:{ 1048: -: 809: /* Fixme: this should be a failure to call this routine */ 1049: #####: 810: return MPI_SUCCESS; 1122: 3273: 865: fn_exit: 1123: 3273: 866: return mpi_errno; 1124: #####: 868: if (pg->connData) { MPIU_Free(pg->connData); } 1160: branch 5 taken 100% 1161: -: 894: /* FIXME: Turn this into a valid error code create/return */ 1162: #####: 895: printf( "Fatal error in getConnInfo (rank = %d)\n", rank ); 1163: call 0 never executed 1164: #####: 896: printf( "connInfo = %p\n", connInfo );fflush(stdout); 1165: call 0 never executed 1166: call 1 never executed 1167: #####: 897: if (connInfo) { 1168: branch 0 never executed 1169: branch 1 never executed 1170: #####: 898: printf( "connInfo->connStrings = %p\n", connInfo->connStrings ); 1172: -: 899: } 1173: -: 900: /* Fatal error. Connection information missing */ 1174: #####: 901: fflush(stdout); 1227: -: 938: MPIU_Assertp(0); /* don't know what to do here for pmi2 yet. DARIUS */ 1228: -: 939:#else 1229: #####: 940: PMI_Get_id( pg->id, 256 ); 1258: branch 0 taken 0% (fallthrough) 1259: branch 1 taken 100% 1260: #####: 959: *buf_p = 0; 1261: #####: 960: *slen = 0; 1262: #####: 961: MPIU_ERR_INTERNALANDJUMP(mpi_errno, "len > connInfo->toStringLen"); 1271: 201: 968: MPIU_CHKPMEM_COMMIT(); 1272: 201: 969: return mpi_errno; 1273: #####: 971: MPIU_CHKPMEM_REAP(); 1426: -: 1097: } 1427: -: 1098: else { 1428: #####: 1099: MPIU_Internal_error_printf( "Panic: no getConnInfo defined!\n" ); 1606: -: 1235:int MPIU_PG_Printall( FILE *fp ) 1607: function MPIU_PG_Printall called 0 returned 0% blocks executed 0% 1608: #####: 1236:{ 1610: -: 1238: int i; 1611: -: 1239: 1612: #####: 1240: pg = MPIDI_PG_list; 1613: -: 1241: 1614: #####: 1242: fprintf( fp, "Process groups:\n" ); 1615: call 0 never executed 1616: #####: 1243: while (pg) { 1618: branch 1 never executed 1619: -: 1244: /* XXX DJG FIXME-MT should we be checking this? */ 1620: #####: 1245: fprintf( fp, "size = %d, refcount = %d, id = %s\n", 1621: call 0 never executed 1622: -: 1246: pg->size, MPIU_Object_get_ref(pg), (char *)pg->id ); 1623: #####: 1247: for (i=0; isize; i++) { 1624: branch 0 never executed 1625: branch 1 never executed 1626: #####: 1248: fprintf( fp, "\tVCT rank = %d, refcount = %d, lpid = %d, state = %d \n", 1629: -: 1250: pg->vct[i].lpid, (int)pg->vct[i].state ); 1630: -: 1251: } 1631: #####: 1252: fflush(fp); 1632: call 0 never executed 1633: #####: 1253: pg = pg->next; 1634: -: 1254: } 1635: -: 1255: 1636: #####: 1256: return 0; 1650: -: 1266: char buf[256]; 1651: -: 1267: /* Force an enroll */ 1652: #####: 1268: PMI_KVS_Get( "foobar", "foobar", buf, sizeof(buf) ); 1653: call 0 never executed 1654: #####: 1269: PMI_Get_id( pg_world->id, 256 ); 1655: call 0 never executed 1656: #####: 1270: PMI_KVS_Get_my_name( pg_world->connData, 256 ); 52 line(s) not covered by tests in src/mpid/ch3/src/mpidi_pg.c.gcov Uncovered lines in src/mpid/ch3/src/mpidi_printf.c.gcov 32: -: 27:void MPIDI_dbg_printf(int level, char * func, char * fmt, ...) 33: function MPIDI_dbg_printf called 0 returned 0% blocks executed 0% 34: #####: 28:{ 42: -: 36: va_list list; 43: -: 37: 44: #####: 38: if (MPIR_Process.comm_world) 46: branch 1 never executed 47: -: 39: { 48: #####: 40: MPIU_dbglog_printf("[%d] %s(): ", MPIR_Process.comm_world->rank, func); 51: -: 42: else 52: -: 43: { 53: #####: 44: MPIU_dbglog_printf("[-1] %s(): ", func); 54: call 0 never executed 55: -: 45: } 56: #####: 46: va_start(list, fmt); 57: call 0 never executed 58: #####: 47: MPIU_dbglog_vprintf(fmt, list); 59: call 0 never executed 60: #####: 48: va_end(list); 61: call 0 never executed 62: #####: 49: MPIU_dbglog_printf("\n"); 63: call 0 never executed 64: #####: 50: fflush(stdout); 70: -: 55:void MPIDI_err_printf(char * func, char * fmt, ...) 71: function MPIDI_err_printf called 0 returned 0% blocks executed 0% 72: #####: 56:{ 74: -: 58: va_list list; 75: -: 59: 76: #####: 60: if (MPIR_Process.comm_world) 78: branch 1 never executed 79: -: 61: { 80: #####: 62: printf("[%d] ERROR - %s(): ", MPIR_Process.comm_world->rank, func); 83: -: 64: else 84: -: 65: { 85: #####: 66: printf("[-1] ERROR - %s(): ", func); 86: call 0 never executed 87: -: 67: } 88: #####: 68: va_start(list, fmt); 89: call 0 never executed 90: #####: 69: vprintf(fmt, list); 91: call 0 never executed 92: #####: 70: va_end(list); 93: call 0 never executed 94: #####: 71: printf("\n"); 95: call 0 never executed 96: #####: 72: fflush(stdout); 240: -: 215:const char * MPIDI_VC_GetStateString(int state) 241: function MPIDI_VC_GetStateString called 0 returned 0% blocks executed 0% 242: #####: 216:{ 243: #####: 217: switch (state) 250: -: 218: { 251: -: 219: case MPIDI_VC_STATE_INACTIVE: 252: #####: 220: return "MPIDI_VC_STATE_INACTIVE"; 253: -: 221: case MPIDI_VC_STATE_ACTIVE: 254: #####: 222: return "MPIDI_VC_STATE_ACTIVE"; 255: -: 223: case MPIDI_VC_STATE_LOCAL_CLOSE: 256: #####: 224: return "MPIDI_VC_STATE_LOCAL_CLOSE"; 257: -: 225: case MPIDI_VC_STATE_REMOTE_CLOSE: 258: #####: 226: return "MPIDI_VC_STATE_REMOTE_CLOSE"; 259: -: 227: case MPIDI_VC_STATE_CLOSE_ACKED: 260: #####: 228: return "MPIDI_VC_STATE_CLOSE_ACKED"; 261: -: 229: default: 262: #####: 230: return "unknown"; 271: -: 239:const char *MPIDI_Pkt_GetDescString( MPIDI_CH3_Pkt_t *pkt ) 272: function MPIDI_Pkt_GetDescString called 0 returned 0% blocks executed 0% 273: #####: 240:{ 275: -: 242: 276: -: 243: /* For data messages, the string (...) is (context,tag,rank,size) */ 277: #####: 244: switch(pkt->type) { 299: branch 21 never executed 300: -: 245: case MPIDI_CH3_PKT_EAGER_SEND: 301: #####: 246: MPIU_Snprintf( pktmsg, sizeof(pktmsg), 306: -: 250: pkt->eager_send.match.parts.rank, 307: -: 251: pkt->eager_send.data_sz ); 308: #####: 252: break; 309: -: 253: case MPIDI_CH3_PKT_EAGER_SYNC_SEND: 310: #####: 254: MPIU_Snprintf( pktmsg, sizeof(pktmsg), 316: -: 259: pkt->eager_sync_send.data_sz, 317: -: 260: pkt->eager_sync_send.sender_req_id ); 318: #####: 261: break; 319: -: 262: case MPIDI_CH3_PKT_EAGER_SYNC_ACK: 320: #####: 263: MPIU_Snprintf( pktmsg, sizeof(pktmsg), 322: -: 264: "EAGER_SYNC_ACK - req=%d", 323: -: 265: pkt->eager_sync_ack.sender_req_id ); 324: #####: 266: break; 325: -: 267: case MPIDI_CH3_PKT_READY_SEND: 326: #####: 268: MPIU_Snprintf( pktmsg, sizeof(pktmsg), 331: -: 272: pkt->ready_send.match.parts.rank, 332: -: 273: pkt->ready_send.data_sz ); 333: #####: 274: break; 334: -: 275: case MPIDI_CH3_PKT_RNDV_REQ_TO_SEND: 335: #####: 276: MPIU_Snprintf( pktmsg, sizeof(pktmsg), 341: -: 281: pkt->rndv_req_to_send.data_sz, 342: -: 282: pkt->rndv_req_to_send.sender_req_id ); 343: #####: 283: break; 344: -: 284: case MPIDI_CH3_PKT_RNDV_CLR_TO_SEND: 345: #####: 285: MPIU_Snprintf( pktmsg, sizeof(pktmsg), 348: -: 287: pkt->rndv_clr_to_send.sender_req_id, 349: -: 288: pkt->rndv_clr_to_send.receiver_req_id ); 350: #####: 289: break; 351: -: 290: case MPIDI_CH3_PKT_RNDV_SEND: 352: #####: 291: MPIU_Snprintf( pktmsg, sizeof(pktmsg), 354: -: 292: "RNDV_SEND - recv req=%d", 355: -: 293: pkt->rndv_send.receiver_req_id ); 356: #####: 294: break; 357: -: 295: case MPIDI_CH3_PKT_CANCEL_SEND_REQ: 358: #####: 296: MPIU_Snprintf( pktmsg, sizeof(pktmsg), 360: -: 297: "CANCEL_SEND_REQ - req=%d", 361: -: 298: pkt->cancel_send_req.sender_req_id ); 362: #####: 299: break; 363: -: 300: case MPIDI_CH3_PKT_CANCEL_SEND_RESP: 364: #####: 301: MPIU_Snprintf( pktmsg, sizeof(pktmsg), 367: -: 303: pkt->cancel_send_resp.sender_req_id, 368: -: 304: pkt->cancel_send_resp.ack ); 369: #####: 305: break; 370: -: 306: case MPIDI_CH3_PKT_PUT: 371: #####: 307: MPIU_Snprintf( pktmsg, sizeof(pktmsg), 375: -: 310: pkt->put.count, 376: -: 311: pkt->put.target_win_handle ); 377: #####: 312: break; 378: -: 313: case MPIDI_CH3_PKT_GET: 379: #####: 314: MPIU_Snprintf( pktmsg, sizeof(pktmsg), 384: -: 318: pkt->get.target_win_handle, 385: -: 319: pkt->get.request_handle ); 386: #####: 320: break; 387: -: 321: case MPIDI_CH3_PKT_GET_RESP: 388: #####: 322: MPIU_Snprintf( pktmsg, sizeof(pktmsg), 390: -: 323: "GET_RESP - req=%d", 391: -: 324: pkt->get_resp.request_handle ); 392: #####: 325: break; 393: -: 326: case MPIDI_CH3_PKT_ACCUMULATE: 394: #####: 327: MPIU_Snprintf( pktmsg, sizeof(pktmsg), 398: -: 330: pkt->accum.count, 399: -: 331: pkt->accum.target_win_handle ); 400: #####: 332: break; 401: -: 333: case MPIDI_CH3_PKT_LOCK: 402: #####: 334: MPIU_Snprintf( pktmsg, sizeof(pktmsg), 404: -: 335: "LOCK - %d", 405: -: 336: pkt->lock.target_win_handle ); 406: #####: 337: break; 407: -: 338: case MPIDI_CH3_PKT_LOCK_PUT_UNLOCK: 408: #####: 339: MPIU_Snprintf( pktmsg, sizeof(pktmsg), 412: -: 342: pkt->lock_put_unlock.count, 413: -: 343: pkt->lock_put_unlock.target_win_handle ); 414: #####: 344: break; 415: -: 345: case MPIDI_CH3_PKT_LOCK_ACCUM_UNLOCK: 416: #####: 346: MPIU_Snprintf( pktmsg, sizeof(pktmsg), 420: -: 349: pkt->lock_accum_unlock.count, 421: -: 350: pkt->lock_accum_unlock.target_win_handle ); 422: #####: 351: break; 423: -: 352: case MPIDI_CH3_PKT_LOCK_GET_UNLOCK: 424: #####: 353: MPIU_Snprintf( pktmsg, sizeof(pktmsg), 429: -: 357: pkt->lock_get_unlock.target_win_handle, 430: -: 358: pkt->lock_get_unlock.request_handle ); 431: #####: 359: break; 432: -: 360: case MPIDI_CH3_PKT_PT_RMA_DONE: 433: -: 361: /* There is no rma_done packet type */ 434: #####: 362: MPIU_Snprintf( pktmsg, sizeof(pktmsg), 436: -: 363: "RMA_DONE - 0x%08X", 437: -: 364: pkt->lock_accum_unlock.source_win_handle ); 438: #####: 365: break; 439: -: 366: case MPIDI_CH3_PKT_LOCK_GRANTED: 440: #####: 367: MPIU_Snprintf( pktmsg, sizeof(pktmsg), 442: -: 368: "LOCK_GRANTED - 0x%08X", 443: -: 369: pkt->lock_granted.source_win_handle ); 444: #####: 370: break; 445: -: 371: case MPIDI_CH3_PKT_FLOW_CNTL_UPDATE: 446: #####: 372: MPIU_Snprintf( pktmsg, sizeof(pktmsg), 447: call 0 never executed 448: -: 373: "FLOW_CNTL_UPDATE" ); 449: #####: 374: break; 450: -: 375: case MPIDI_CH3_PKT_CLOSE: 451: #####: 376: MPIU_Snprintf( pktmsg, sizeof(pktmsg), 453: -: 377: "CLOSE ack=%d", 454: -: 378: pkt->close.ack ); 455: #####: 379: break; 456: -: 380: 457: -: 381: default: 458: #####: 382: MPIU_Snprintf( pktmsg, sizeof(pktmsg), 462: -: 385: } 463: -: 386: 464: #####: 387: return pktmsg; 72 line(s) not covered by tests in src/mpid/ch3/src/mpidi_printf.c.gcov All code covered by tests in src/mpid/ch3/util/shm/ch3u_get_business_card_sshm.c.gcov Uncovered lines in src/mpid/ch3/util/shm/ch3u_init_sshm.c.gcov 148: branch 0 taken 0% (fallthrough) 149: branch 1 taken 100% 150: #####: 106: pgch->nShmWaitSpinCount = 1; 392: -: 297: { 393: -: 298: /* The root process initialized the queue */ 394: #####: 299: initialize_queue = 0; 596: branch 1 taken 100% (fallthrough) 597: -: 453: { 598: #####: 454: min_rank = MPIU_MIN(min_rank, ranks[i]); 3 line(s) not covered by tests in src/mpid/ch3/util/shm/ch3u_init_sshm.c.gcov All code covered by tests in src/mpid/ch3/util/shm/ch3u_finalize_sshm.c.gcov Uncovered lines in src/mpid/ch3/util/shm/ch3i_bootstrapq.c.gcov 350: call 0 never executed 351: -: 334: __LINE__, MPI_ERR_OTHER, "**nomem", 0); 352: #####: 336: return mpi_errno; 369: call 0 never executed 370: -: 347: __LINE__, MPI_ERR_OTHER, "**mqshm_create", 0); 371: #####: 349: return mpi_errno; 401: -: 376:int MPIDI_CH3I_BootstrapQ_create(MPIDI_CH3I_BootstrapQ *queue_ptr) 402: function MPIDI_CH3I_BootstrapQ_create called 0 returned 0% blocks executed 0% 403: #####: 377:{ 404: #####: 378: int mpi_errno = MPI_SUCCESS; 416: -: 390: MPIDI_FUNC_ENTER(MPID_STATE_MPIDI_CH3I_BOOTSTRAPQ_CREATE); 417: -: 391: 418: #####: 392: if (g_queue_list) 420: branch 1 never executed 421: -: 393: { 422: #####: 394: *queue_ptr = g_queue_list; 423: #####: 394: *queue_ptr = g_queue_list; 424: #####: 396: return MPI_SUCCESS; 425: -: 397: } 426: -: 398: 427: #####: 399: queue = (MPIDI_CH3I_BootstrapQ_struct*) 428: call 0 never executed 429: -: 400: MPIU_Malloc(sizeof(MPIDI_CH3I_BootstrapQ_struct)); 430: #####: 401: if (queue == NULL) 436: call 0 never executed 437: -: 404: __LINE__, MPI_ERR_OTHER, "**nomem", 0); 438: #####: 406: return mpi_errno; 439: -: 407: } 440: #####: 408: queue->next = NULL; 441: #####: 409: g_queue_list = queue; 443: -: 411:#ifdef USE_MQSHM 444: -: 412: 445: #####: 413: queue->id = -1; 447: #####: 413: queue->id = -1; 448: call 0 never executed 449: #####: 416: return mpi_errno; 629: -: 591: { 630: call 0 never executed 631: #####: 594: return mpi_errno; 643: -: 601: { 644: call 0 never executed 645: #####: 604: return mpi_errno; 678: -: 631: { 679: call 0 never executed 680: #####: 634: return mpi_errno; 789: branch 2 taken 100% 790: -: 730: { 791: #####: 731: *queue_ptr = iter; 792: #####: 731: *queue_ptr = iter; 793: #####: 733: return MPI_SUCCESS; 811: 8780: 746: break; 812: -: 747: } 813: #####: 748: iter = iter->next; 818: -: 751: { 819: -: 752: /* This is a queue this process hasn't seen before, so "create" it (attach to existing) */ 820: #####: 753: mpi_errno = MPIDI_CH3I_BootstrapQ_create_named(&matched_queue, shm_name, 0); 821: call 0 never executed 822: #####: 754: if (mpi_errno != MPI_SUCCESS) 828: call 0 never executed 829: -: 757: __LINE__, MPI_ERR_OTHER, "**fail", 0); 830: #####: 759: return mpi_errno; 831: -: 760: } 832: -: 761: /* change the pid field to match the remote process */ 833: #####: 762: MPIU_Strncpy(matched_queue->name, name, MPIDI_BOOTSTRAP_NAME_LEN); 834: call 0 never executed 835: #####: 763: matched_queue->pid = atoi(name); 836: call 0 never executed 837: #####: 764: *queue_ptr = matched_queue; 838: #####: 764: *queue_ptr = matched_queue; 839: #####: 766: return mpi_errno; 852: call 0 never executed 853: -: 775: __LINE__, MPI_ERR_OTHER, "**nomem", 0); 854: #####: 777: return mpi_errno; 1174: -: 1082: __LINE__, MPI_ERR_OTHER, 1175: -: 1083: "**mqshm_receive", 0); 1176: #####: 1085: return mpi_errno; 29 line(s) not covered by tests in src/mpid/ch3/util/shm/ch3i_bootstrapq.c.gcov All code covered by tests in src/mpid/ch3/util/shm/stdlib.h.gcov Uncovered lines in src/mpid/ch3/util/shm/ch3i_shm_bootstrapq.c.gcov 59: branch 1 taken 0% 60: 5326625: 50: return iter->q_ptr; 61: #####: 51: iter = iter->next; 62: -: 52: } 63: #####: 53: return NULL; 84: -: 69: { 85: call 0 never executed 86: #####: 72: return mpi_errno; 97: -: 78: { 98: call 0 never executed 99: #####: 81: return mpi_errno; 120: -: 96: { 121: call 0 never executed 122: #####: 99: return mpi_errno; 189: branch 1 taken 100% 190: -: 154: { 191: #####: 155: trailer->next = iter->next; 200: 3268: 163: return MPI_SUCCESS; 201: -: 164: } 202: #####: 165: if (trailer != iter) 203: branch 0 never executed 204: branch 1 never executed 205: #####: 166: trailer = trailer->next; 206: #####: 167: iter = iter->next; 207: #####: 167: iter = iter->next; 208: -: 168: } 209: #####: 170: return MPI_SUCCESS; 242: 6541: 194: return MPI_SUCCESS; 243: -: 195: } 244: #####: 196: iter = iter->next; 247: -: 197: } 248: call 0 never executed 249: #####: 200: return mpi_errno; 269: -: 215: { 270: call 0 never executed 271: #####: 218: return mpi_errno; 282: -: 224: { 283: call 0 never executed 284: #####: 227: return mpi_errno; 369: -: 281: q_ptr->inuse = 0; 370: -: 282:#endif 371: #####: 283: MPIDU_Process_unlock(&q_ptr->lock); 372: call 0 never executed 373: #####: 284: MPIDU_Yield(); 374: call 0 never executed 375: #####: 285: } while (blocking); 376: branch 0 never executed 377: branch 1 never executed 378: #####: 286: *num_sent = 0; 379: #####: 286: *num_sent = 0; 380: #####: 288: return MPI_SUCCESS; 404: -: 306: { 405: call 0 never executed 406: #####: 309: return mpi_errno; 449: -: 341: q_ptr->inuse = 0; 450: -: 342:#endif 451: #####: 343: MPIDU_Process_unlock(&q_ptr->lock); 454: call 0 never executed 455: call 0 never executed 456: #####: 346: return mpi_errno; 614: branch 7 never executed 615: -: 455: strlen(pOutput->name) > 30) { 616: #####: 456: pOutput->name[30] = 0; 617: #####: 457: pOutput->id = shm_open(pOutput->name, O_RDWR | O_CREAT, 0600); 623: branch 1 taken 100% 624: -: 461: { 625: #####: 462: pOutput->error = errno; 626: call 0 never executed 627: #####: 463: perror("shm_open msg" ); 639: branch 2 taken 100% 640: -: 470: { 641: #####: 471: pOutput->error = errno; 642: call 0 never executed 643: #####: 472: perror( "ftrunctate" ); 700: call 0 never executed 701: call 1 never executed 702: #####: 523: pOutput->addr = NULL; 29 line(s) not covered by tests in src/mpid/ch3/util/shm/ch3i_shm_bootstrapq.c.gcov All code covered by tests in src/mpid/ch3/util/shm/mpidu_process_locks.h.gcov All code covered by tests in src/mpid/ch3/util/shm/mpiimpl.h.gcov Uncovered lines in src/mpid/ch3/util/shm/ch3u_connect_sshm.c.gcov 32: -: 27: MPIDI_VC_t ** new_vc) 33: function MPIDI_CH3I_Connect_to_root_sshm called 0 returned 0% blocks executed 0% 34: #####: 28:{ 35: #####: 29: int mpi_errno = MPI_SUCCESS; 36: -: 30: MPIDI_VC_t * vc; 37: -: 31: MPIDI_CH3I_VC *vcch; 38: #####: 32: MPIU_CHKPMEM_DECL(1); 41: -: 35: MPIDI_CH3_Pkt_t pkt; 42: -: 36: MPIDI_CH3I_Pkt_sc_conn_accept_t *acceptpkt = 43: #####: 37: (MPIDI_CH3I_Pkt_sc_conn_accept_t *)&pkt; 44: -: 38: int num_written; 45: #####: 39: char *cached_pg_id, *dummy_id = ""; 48: -: 42: MPIDI_FUNC_ENTER(MPID_STATE_MPIDI_CH3I_CONNECT_TO_ROOT_SSHM); 49: -: 43: 50: #####: 44: mpi_errno = MPIDI_GetTagFromPort(port_name, &port_name_tag); 51: call 0 never executed 52: #####: 45: if (mpi_errno != MPIU_STR_SUCCESS) { 58: -: 48: MPIU_DBG_MSG_D(CH3_CONNECT,VERBOSE,"port tag %d",port_name_tag); 59: -: 49: 60: #####: 50: if (*new_vc != NULL) 63: -: 51: { 64: -: 52: MPIU_DBG_MSG(CH3_CONNECT,VERBOSE,"using old connection"); 65: #####: 53: vc = *new_vc; 67: -: 55: else 68: -: 56: { 69: #####: 57: MPIU_CHKPMEM_MALLOC(vc,MPIDI_VC_t *,sizeof(MPIDI_VC_t),mpi_errno,"vc"); 78: -: 58: /* FIXME - where does this vc get freed? */ 79: -: 59: 80: #####: 60: *new_vc = vc; 81: -: 61: 82: #####: 62: MPIDI_VC_Init(vc, NULL, 0); 83: call 0 never executed 84: -: 63: } 85: #####: 64: vcch = (MPIDI_CH3I_VC *)vc->channel_private; 86: #####: 65: vcch->state = MPIDI_CH3I_VC_STATE_CONNECTING; 87: -: 66: 88: #####: 67: connected = FALSE; 89: -: 68: /* Make it so that the pg_id is not matched on the other side by sending a 90: -: 69: dummy value */ 91: #####: 70: cached_pg_id = MPIDI_Process.my_pg->id; 92: #####: 71: MPIDI_Process.my_pg->id = dummy_id; 93: #####: 72: mpi_errno = MPIDI_CH3I_Shm_connect(vc, port_name, &connected); 94: call 0 never executed 95: #####: 73: MPIDI_Process.my_pg->id = cached_pg_id; 96: #####: 74: if (mpi_errno != MPI_SUCCESS) { 99: -: 75: /* FIXME: Do we want to free the vc instead? Or put this into the fail 100: -: 76: block? */ 101: #####: 77: vcch->state = MPIDI_CH3I_VC_STATE_FAILED; 103: call 0 never executed 104: -: 79: } 105: #####: 80: if (!connected) { 113: -: 85: } 114: -: 86: 115: #####: 87: MPIDI_CH3I_SHM_Add_to_writer_list(vc); 116: call 0 never executed 117: #####: 88: vcch->state = MPIDI_CH3I_VC_STATE_CONNECTED; 118: #####: 89: vcch->shm_reading_pkt = TRUE; 119: #####: 90: vcch->send_active = MPIDI_CH3I_SendQ_head(vcch); /* MT */ 120: -: 91: 121: #####: 92: MPIDI_Pkt_init(acceptpkt, MPIDI_CH3I_PKT_SC_CONN_ACCEPT); 122: #####: 93: acceptpkt->port_name_tag = port_name_tag; 123: -: 94: 124: #####: 95: mpi_errno = MPIDI_CH3I_SHM_write(vc, acceptpkt, sizeof(MPIDI_CH3_Pkt_t), 125: call 0 never executed 126: -: 96: &num_written); 127: #####: 97: if (mpi_errno != MPI_SUCCESS || num_written != sizeof(MPIDI_CH3_Pkt_t)) { 134: -: 99: } 135: -: 100: 136: #####: 101: fn_exit: 137: #####: 101: fn_exit: 138: #####: 103: return mpi_errno; 139: #####: 103: return mpi_errno; 140: #####: 105: MPIU_CHKPMEM_REAP(); 33 line(s) not covered by tests in src/mpid/ch3/util/shm/ch3u_connect_sshm.c.gcov Uncovered lines in src/mpid/common/sock/poll/sock_wait.i.gcov 221: 154736014: 199: goto fn_exit; 222: -: 200: } 223: #####: 201: else if (errno == EINTR) 226: branch 2 never executed 227: -: 202: { 228: #####: 203: if (millisecond_timeout != MPIDU_SOCK_INFINITE_TIME) 230: branch 1 never executed 231: -: 204: { 232: #####: 205: mpi_errno = MPIDU_SOCK_ERR_TIMEOUT; 233: #####: 206: goto fn_exit; 320: -: 260: MPI_SUCCESS, MPIR_ERR_FATAL, FCNAME, __LINE__, MPIDU_SOCK_ERR_FAIL, "**sock|badhandle", 321: -: 261: "**sock|poll|badhandle %d %d %d %d", pollinfo->sock_set->id, pollinfo->sock_id, pollfd->fd, pollinfo->fd); 322: #####: 262: goto fn_exit; 511: -: 401:static int MPIDU_Socki_handle_pollhup(struct pollfd * const pollfd, struct pollinfo * const pollinfo) 512: function MPIDU_Socki_handle_pollhup called 0 returned 0% blocks executed 0% 513: #####: 402:{ 514: #####: 403: int mpi_errno = MPI_SUCCESS; 517: -: 406: MPIDI_FUNC_ENTER(MPID_STATE_MPIDU_SOCKI_HANDLE_POLLHUP); 518: -: 407: 519: #####: 408: if (pollinfo->state == MPIDU_SOCKI_STATE_CONNECTED_RW) 549: -: 413: */ 550: -: 428: } 551: #####: 429: else if (pollinfo->state == MPIDU_SOCKI_STATE_CONNECTED_RO) 561: -: 437: * list. 562: -: 438: */ 563: #####: 439: MPIU_Assert(pollinfo->state == MPIDU_SOCKI_STATE_CONNECTED_RO && (pollfd->events & POLLIN) && (pollfd->revents & POLLIN)); 571: call 7 never executed 572: -: 440: } 573: #####: 441: else if (pollinfo->state == MPIDU_SOCKI_STATE_DISCONNECTED) 578: -: 444: * We should never reach this state because pollfd->fd should be set to -1 if we are in the disconnected state. 579: -: 445: */ 580: #####: 446: MPIU_Assert(pollinfo->state == MPIDU_SOCKI_STATE_DISCONNECTED && pollfd->fd == -1); 586: call 5 never executed 587: -: 447: } 588: #####: 448: else if (pollinfo->state == MPIDU_SOCKI_STATE_CONNECTING) 593: -: 451: * The process we were connecting to died. Let the POLLOUT handler deal with the error. 594: -: 452: */ 595: #####: 453: MPIU_Assert(pollinfo->state == MPIDU_SOCKI_STATE_CONNECTING && (pollfd->events & POLLOUT)); 600: call 4 never executed 601: call 5 never executed 602: #####: 454: pollfd->revents = POLLOUT; 613: -: 455: } 614: -: 465: 615: #####: 466: fn_exit: 616: #####: 466: fn_exit: 617: #####: 468: return mpi_errno; 626: -: 477:static int MPIDU_Socki_handle_pollerr(struct pollfd * const pollfd, struct pollinfo * const pollinfo) 627: function MPIDU_Socki_handle_pollerr called 0 returned 0% blocks executed 0% 628: #####: 478:{ 629: #####: 479: int mpi_errno = MPI_SUCCESS; 645: -: 483: 646: -: 493: 647: #####: 494: if (pollinfo->state == MPIDU_SOCKI_STATE_CONNECTED_RW) 654: -: 499: * Here, we simple check that things are as we expect them to be. 655: -: 500: */ 656: #####: 501: MPIU_Assert((pollfd->events & (POLLIN | POLLOUT)) || pollfd->fd == -1); 663: -: 502: 664: -: 503: /* If a write was posted then cancel it and generate an write completion event */ 665: #####: 504: if (pollfd->events & POLLOUT) 671: -: 508: int event_mpi_errno; 672: -: 509: 673: #####: 510: MPIDU_SOCKI_GET_SOCKET_ERROR(pollinfo, os_errno, mpi_errno, fn_exit); 682: call 8 never executed 683: -: 511: 684: #####: 512: event_mpi_errno = MPIDU_Socki_os_to_mpi_errno(pollinfo, os_errno, FCNAME, __LINE__, &disconnected); 695: call 0 never executed 696: -: 520: 697: #####: 521: MPIDU_SOCKI_EVENT_ENQUEUE(pollinfo, MPIDU_SOCK_OP_WRITE, pollinfo->write_nb, pollinfo->user_ptr, 701: call 3 never executed 702: -: 522: event_mpi_errno, mpi_errno, fn_exit); 703: #####: 523: MPIDU_SOCKI_POLLFD_OP_CLEAR(pollfd, pollinfo, POLLOUT); 704: branch 0 never executed 705: branch 1 never executed 706: #####: 524: pollinfo->state = MPIDU_SOCKI_STATE_CONNECTED_RO; 707: -: 525: } 708: -: 526: } 709: #####: 527: else if (pollinfo->state == MPIDU_SOCKI_STATE_CONNECTED_RO) 719: -: 535: * list. 720: -: 536: */ 721: #####: 537: MPIU_Assert(pollinfo->state == MPIDU_SOCKI_STATE_CONNECTED_RO && (pollfd->events & POLLIN) && (pollfd->revents & POLLIN)); 729: call 7 never executed 730: -: 538: } 731: #####: 539: else if (pollinfo->state == MPIDU_SOCKI_STATE_CONNECTING) 736: -: 542: * The process we were connecting to died. Let the POLLOUT handler deal with the error. 737: -: 543: */ 738: #####: 544: MPIU_Assert(pollinfo->state == MPIDU_SOCKI_STATE_CONNECTING && (pollfd->events & POLLOUT)); 743: call 4 never executed 744: call 5 never executed 745: #####: 545: pollfd->revents = POLLOUT; 746: -: 546: } 747: #####: 547: else if (pollinfo->state == MPIDU_SOCKI_STATE_DISCONNECTED) 750: -: 548: { 751: -: 549: /* We are already disconnected! Why are we handling an error? */ 752: #####: 550: MPIU_Assert(pollfd->fd == -1); 767: -: 551: } 768: -: 561: 769: #####: 562: fn_exit: 770: #####: 562: fn_exit: 771: #####: 564: return mpi_errno; 796: -: 586: { 797: -: 587: MPIDI_FUNC_ENTER(MPID_STATE_READV); 798: #####: 588: nb = readv(pollinfo->fd, pollinfo->read.iov.ptr + pollinfo->read.iov.offset, 883: -: 617: } 884: -: 618: } 885: #####: 640: else if (errno == EAGAIN && errno == EWOULDBLOCK) 889: -: 641: { 890: -: 642: /* do nothing... */ 891: #####: 643: goto fn_exit; 1028: -: 736: } 1029: -: 737: } 1030: #####: 738: else if (errno == EAGAIN || errno == EWOULDBLOCK) 1034: -: 739: { 1035: -: 740: /* do nothing... */ 1036: #####: 741: goto fn_exit; 41 line(s) not covered by tests in src/mpid/common/sock/poll/sock_wait.i.gcov Uncovered lines in src/mpid/common/sock/poll/sock_misc.i.gcov 53: -: 48: char * host_description, int len) 54: function MPIDU_Sock_get_host_description called 0 returned 0% blocks executed 0% 55: #####: 49:{ 56: -: 50: char * env_hostname; 57: -: 51: int rc; 58: #####: 52: int mpi_errno = MPI_SUCCESS; 79: -: 70: name? What if a different interface is needed? */ 80: -: 71: /* Use hostname supplied in environment variable, if it exists */ 81: #####: 72: env_hostname = getenv("MPICH_INTERFACE_HOSTNAME"); 82: call 0 never executed 83: -: 73: 84: #####: 74: if (!env_hostname) { 89: -: 77: environment to each process */ 90: -: 78: char namebuf[1024]; 91: #####: 79: MPIU_Snprintf( namebuf, sizeof(namebuf), 92: call 0 never executed 93: -: 80: "MPICH_INTERFACE_HOSTNAME_R_%d", myRank ); 94: #####: 81: env_hostname = getenv( namebuf ); 96: -: 82: } 97: -: 83: 98: #####: 84: if (env_hostname != NULL) 100: branch 1 never executed 101: -: 85: { 102: #####: 86: rc = MPIU_Strncpy(host_description, env_hostname, (size_t) len); 114: -: 94: } 115: -: 95: else { 116: #####: 96: rc = gethostname(host_description, len); 152: -: 117: } 153: -: 118: 154: #####: 119: fn_exit: 155: #####: 119: fn_exit: 156: #####: 121: return mpi_errno; 165: -: 130: struct MPIDU_Sock ** sockp) 166: function MPIDU_Sock_native_to_sock called 0 returned 0% blocks executed 0% 167: #####: 131:{ 168: #####: 132: struct MPIDU_Sock * sock = NULL; 171: -: 135: int rc; 172: -: 136: long flags; 173: #####: 137: int mpi_errno = MPI_SUCCESS; 179: -: 143: 180: -: 144: /* allocate sock and poll structures */ 181: #####: 145: mpi_errno = MPIDU_Socki_sock_alloc(sock_set, &sock); 193: call 0 never executed 194: -: 154: 195: #####: 155: pollfd = MPIDU_Socki_sock_get_pollfd(sock); 196: #####: 156: pollinfo = MPIDU_Socki_sock_get_pollinfo(sock); 197: -: 157: 198: -: 158: /* set file descriptor to non-blocking */ 199: #####: 159: flags = fcntl(fd, F_GETFL, 0); 213: #####: 159: flags = fcntl(fd, F_GETFL, 0); 214: call 0 never executed 215: #####: 168: rc = fcntl(fd, F_SETFL, flags | O_NONBLOCK); 231: -: 177: 232: -: 178: /* initialize sock and poll structures */ 233: #####: 179: pollfd->fd = -1; 234: #####: 180: pollfd->events = 0; 235: #####: 181: pollfd->revents = 0; 236: -: 182: 237: #####: 183: pollinfo->fd = fd; 238: #####: 184: pollinfo->user_ptr = user_ptr; 239: #####: 185: pollinfo->type = MPIDU_SOCKI_TYPE_COMMUNICATION; 240: #####: 186: pollinfo->state = MPIDU_SOCKI_STATE_CONNECTED_RW; 241: -: 187: 242: #####: 188: *sockp = sock; 243: -: 189: 244: #####: 190: fn_exit: 245: #####: 190: fn_exit: 246: #####: 192: return mpi_errno; 267: -: 210:int MPIDU_Sock_set_user_ptr(struct MPIDU_Sock * sock, void * user_ptr) 268: function MPIDU_Sock_set_user_ptr called 0 returned 0% blocks executed 0% 269: #####: 211:{ 270: #####: 212: int mpi_errno = MPI_SUCCESS; 275: -: 217: MPIDU_SOCKI_VERIFY_INIT(mpi_errno, fn_exit); 276: -: 218: 277: #####: 219: if (sock != MPIDU_SOCK_INVALID_SOCK && 282: -: 220: sock->sock_set != MPIDU_SOCK_INVALID_SET) 283: -: 221: { 284: #####: 222: MPIDU_Socki_sock_get_pollinfo(sock)->user_ptr = user_ptr; 297: -: 233: fn_exit: 298: -: 234:#endif 299: #####: 236: return mpi_errno; 309: -: 246:int MPIDU_Sock_get_sock_id(struct MPIDU_Sock * sock) 310: function MPIDU_Sock_get_sock_id called 0 returned 0% blocks executed 0% 311: #####: 247:{ 315: -: 251: MPIDI_FUNC_ENTER(MPID_STATE_MPIDU_SOCK_GET_SOCK_ID); 316: -: 252: 317: #####: 253: if (sock != MPIDU_SOCK_INVALID_SOCK) 319: branch 1 never executed 320: -: 254: { 321: #####: 255: if (sock->sock_set != MPIDU_SOCK_INVALID_SET) 323: branch 1 never executed 324: -: 256: { 325: #####: 257: id = MPIDU_Socki_sock_get_pollinfo(sock)->sock_id; 327: -: 259: else 328: -: 260: { 329: #####: 261: id = -1; 332: -: 264: else 333: -: 265: { 334: #####: 266: id = -1; 336: -: 267: } 337: -: 268: 338: #####: 270: return id; 345: -: 277:int MPIDU_Sock_get_sock_set_id(struct MPIDU_Sock_set * sock_set) 346: function MPIDU_Sock_get_sock_set_id called 0 returned 0% blocks executed 0% 347: #####: 278:{ 351: -: 282: MPIDI_FUNC_ENTER(MPID_STATE_MPIDU_SOCK_GET_SOCK_SET_ID); 352: -: 283: 353: #####: 284: if (sock_set != MPIDU_SOCK_INVALID_SET) 355: branch 1 never executed 356: -: 285: { 357: #####: 286: id = sock_set->id; 359: -: 288: else 360: -: 289: { 361: #####: 290: id = -1; 363: -: 291: } 364: -: 292: 365: #####: 294: return id; 46 line(s) not covered by tests in src/mpid/common/sock/poll/sock_misc.i.gcov Uncovered lines in src/mpid/common/sock/poll/sock_immed.i.gcov 330: -: 262: MPIU_Size_t * num_read) 331: function MPIDU_Sock_read called 0 returned 0% blocks executed 0% 332: #####: 263:{ 334: -: 265: struct pollinfo * pollinfo; 335: -: 266: size_t nb; 336: #####: 267: int mpi_errno = MPI_SUCCESS; 343: -: 274: MPIDU_SOCKI_VALIDATE_SOCK(sock, mpi_errno, fn_exit); 344: -: 275: 345: #####: 276: pollfd = MPIDU_Socki_sock_get_pollfd(sock); 346: #####: 277: pollinfo = MPIDU_Socki_sock_get_pollinfo(sock); 357: -: 288: (which is also missing!!!!) needs to be very clear about this 358: -: 289: requirement. */ 359: #####: 290: if (len > SSIZE_MAX) 361: branch 1 never executed 362: -: 291: { 363: #####: 292: len = SSIZE_MAX; 367: -: 296: { 368: -: 297: MPIDI_FUNC_ENTER(MPID_STATE_READ); 369: #####: 298: nb = read(pollinfo->fd, buf, len); 371: call 0 never executed 372: -: 300: } 373: #####: 301: while (nb == -1 && errno == EINTR); 378: branch 4 never executed 379: -: 302: 380: #####: 303: if (nb > 0) 382: branch 1 never executed 383: -: 304: { 384: #####: 305: *num_read = (MPIU_Size_t) nb; 475: -: 306: } 476: -: 368: 477: #####: 369: fn_exit: 478: #####: 369: fn_exit: 479: #####: 371: return mpi_errno; 666: branch 1 taken 100% 667: -: 518: { 668: #####: 519: len = SSIZE_MAX; 851: -: 665:int MPIDU_Sock_wakeup(struct MPIDU_Sock_set * sock_set) 852: function MPIDU_Sock_wakeup called 0 returned 0% blocks executed 0% 853: #####: 666:{ 854: #####: 667: int mpi_errno = MPI_SUCCESS; 882: -: 694: fn_exit: 883: -: 695:#endif 884: #####: 697: return mpi_errno; 16 line(s) not covered by tests in src/mpid/common/sock/poll/sock_immed.i.gcov Uncovered lines in src/mpid/common/sock/poll/sock_post.i.gcov 198: -: 143: /* connection succeeded */ 199: -: 144: MPIU_DBG_MSG_P(CH3_CONNECT,TYPICAL,"Setting state to SOCKI_STATE_CONNECTED_RW for sock %p",sock); 200: #####: 145: pollinfo->state = MPIDU_SOCKI_STATE_CONNECTED_RW; 201: #####: 146: MPIDU_SOCKI_EVENT_ENQUEUE(pollinfo, MPIDU_SOCK_OP_CONNECT, 0, user_ptr, MPI_SUCCESS, mpi_errno, fn_fail); 401: branch 1 taken 100% 402: -: 295: { 403: #####: 296: optval = 1; 404: #####: 297: rc = setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(int)); 491: branch 0 taken 100% (fallthrough) 492: branch 1 taken 0% 493: #####: 350: if (errno != EADDRINUSE && errno != EADDRNOTAVAIL) { 495: branch 1 never executed 496: branch 2 never executed 497: #####: 351: close(fd); 498: call 0 never executed 499: #####: 352: break; 505: -: 358: } 506: -: 359: else { 507: #####: 360: memset(&addr, 0, sizeof(addr)); 508: call 0 never executed 509: #####: 361: addr.sin_family = AF_INET; 510: #####: 362: addr.sin_addr.s_addr = htonl(INADDR_ANY); 512: branch 1 never executed 513: branch 2 never executed 514: #####: 363: addr.sin_port = htons((unsigned short) *port); 516: branch 1 never executed 517: branch 2 never executed 518: #####: 364: rc = bind(fd, (struct sockaddr *) &addr, sizeof(addr)); 702: -: 509:int MPIDU_Sock_post_readv(struct MPIDU_Sock * sock, MPID_IOV * iov, int iov_n, MPIDU_Sock_progress_update_func_t fn) 703: function MPIDU_Sock_post_readv called 0 returned 0% blocks executed 0% 704: #####: 510:{ 705: -: 511: struct pollfd * pollfd; 706: -: 512: struct pollinfo * pollinfo; 707: #####: 513: int mpi_errno = MPI_SUCCESS; 713: -: 519: MPIDU_SOCKI_VALIDATE_SOCK(sock, mpi_errno, fn_exit); 714: -: 520: 715: #####: 521: pollfd = MPIDU_Socki_sock_get_pollfd(sock); 716: #####: 522: pollinfo = MPIDU_Socki_sock_get_pollinfo(sock); 733: -: 527: 734: -: 537: 735: #####: 538: pollinfo->read.iov.ptr = iov; 736: #####: 539: pollinfo->read.iov.count = iov_n; 737: #####: 540: pollinfo->read.iov.offset = 0; 738: #####: 541: pollinfo->read_iov_flag = TRUE; 739: #####: 542: pollinfo->read_nb = 0; 740: #####: 543: pollinfo->read_progress_update_fn = fn; 741: -: 544: 742: #####: 545: MPIDU_SOCKI_POLLFD_OP_SET(pollfd, pollinfo, POLLIN); 743: -: 546: 744: #####: 547: fn_exit: 745: #####: 547: fn_exit: 746: #####: 549: return mpi_errno; 25 line(s) not covered by tests in src/mpid/common/sock/poll/sock_post.i.gcov All code covered by tests in src/mpid/common/sock/poll/sock_set.i.gcov All code covered by tests in src/mpid/common/sock/poll/sock_init.i.gcov Uncovered lines in src/mpid/common/sock/poll/socki_util.i.gcov 582: -: 548: else 583: -: 549: { 584: #####: 550: iov[offset].MPID_IOV_BUF = (char *) iov[offset].MPID_IOV_BUF + nb; 585: #####: 551: iov[offset].MPID_IOV_LEN -= nb; 586: #####: 552: *offsetp = offset; 587: #####: 553: return FALSE; 699: -: 642:# ifndef MPICH_IS_THREADED 700: -: 643: { 701: #####: 644: memcpy(pollfds, sock_set->pollfds, sock_set->poll_array_sz * sizeof(struct pollfd)); 702: call 0 never executed 703: #####: 645: MPIU_Free(sock_set->pollfds); 717: -: 658:# endif 718: -: 659: 719: #####: 660: memcpy(pollinfos, sock_set->pollinfos, sock_set->poll_array_sz * sizeof(struct pollinfo)); 720: call 0 never executed 721: #####: 661: MPIU_Free(sock_set->pollinfos); 1133: -: 996: socklen_t bufsz_len; 1134: -: 997: 1135: #####: 998: bufsz = sockBufSize; 1136: #####: 999: bufsz_len = sizeof(bufsz); 1137: #####: 1000: rc = setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &bufsz, bufsz_len); 1138: call 0 never executed 1139: #####: 1001: if (rc == -1) { 1149: -: 1005: bufsz, errno, MPIU_Strerror(errno)); 1150: -: 1006: } 1151: #####: 1007: bufsz = sockBufSize; 1152: #####: 1008: bufsz_len = sizeof(bufsz); 1153: #####: 1009: rc = setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &bufsz, bufsz_len); 1154: call 0 never executed 1155: #####: 1010: if (rc == -1) { 1165: -: 1014: bufsz, errno, MPIU_Strerror(errno)); 1166: -: 1015: } 1167: #####: 1016: bufsz_len = sizeof(bufsz); 1168: -: 1017: 1169: #####: 1018: if (firm) { 1170: branch 0 never executed 1171: branch 1 never executed 1172: #####: 1019: rc = getsockopt(fd, SOL_SOCKET, SO_SNDBUF, &bufsz, &bufsz_len); 1186: call 0 never executed 1187: -: 1028: 1188: #####: 1029: bufsz_len = sizeof(bufsz); 1189: #####: 1030: rc = getsockopt(fd, SOL_SOCKET, SO_RCVBUF, &bufsz, &bufsz_len); 1211: -: 1046:int MPIDU_Sock_AddrToStr( MPIDU_Sock_ifaddr_t *ifaddr, char *str, int maxlen ) 1212: function MPIDU_Sock_AddrToStr called 0 returned 0% blocks executed 0% 1213: #####: 1047:{ 1214: -: 1048: int i; 1215: #####: 1049: unsigned char *p = ifaddr->ifaddr; 1216: #####: 1050: for (i=0; ilen && maxlen > 4; i++) { 1217: branch 0 never executed 1218: branch 1 never executed 1219: #####: 1051: snprintf( str, maxlen, "%.3d.", *p++ ); 1220: call 0 never executed 1221: #####: 1052: str += 4; 1222: #####: 1053: maxlen -= 4; 1223: -: 1054: } 1224: -: 1055: /* Change the last period to a null; but be careful in case len was zero */ 1225: #####: 1056: if (i > 0) *--str = 0; 1226: branch 0 never executed 1227: branch 1 never executed 1228: #####: 1057: else *str = 0; 1229: #####: 1058: return 0; 30 line(s) not covered by tests in src/mpid/common/sock/poll/socki_util.i.gcov All code covered by tests in src/mpid/ch3/util/sock/ch3u_init_sock.c.gcov Uncovered lines in src/mpid/ch3/util/sock/ch3u_connect_sock.c.gcov 111: branch 0 taken 0% (fallthrough) 112: branch 1 taken 100% 113: #####: 104: return mpi_errno; 153: branch 0 taken 0% (fallthrough) 154: branch 1 taken 100% 155: #####: 139: return mpi_errno; 236: 6073: 192: fn_exit: 237: 6073: 194: return mpi_errno; 238: #####: 196: MPIU_CHKPMEM_REAP(); 455: branch 1 taken 100% 456: -: 364: /* --BEGIN ERROR HANDLING */ 457: #####: 365: if (str_errno == MPIU_STR_FAIL) { 658: branch 0 taken 0% (fallthrough) 659: branch 1 taken 100% 660: #####: 530: if (mpi_errno == MPIU_STR_NOMEM) { 1185: -: 922: /* the other process is in the same comm_world; just compare the 1186: -: 923: ranks */ 1187: #####: 924: if (MPIR_Process.comm_world->rank < pg_rank) { 1193: -: 928: /* accept connection */ 1194: -: 929: MPIU_DBG_VCCHSTATECHANGE(vc,VC_STATE_CONNECTING); 1195: #####: 930: vcch->state = MPIDI_CH3I_VC_STATE_CONNECTING; 1196: #####: 931: vcch->sock = conn->sock; 1197: #####: 932: vcch->conn = conn; 1198: #####: 933: conn->vc = vc; 1199: -: 934: 1200: #####: 935: MPIDI_Pkt_init(openresp, MPIDI_CH3I_PKT_SC_OPEN_RESP); 1201: #####: 936: openresp->ack = TRUE; 1205: -: 940: MPIU_DBG_MSG_FMT(CH3_CONNECT,TYPICAL,(MPIU_DBG_FDEST, 1206: -: 941: "vc=%p,conn=%p:Refuse head-to-head connection (my process group)",vc,conn)); 1207: #####: 942: MPIDI_Pkt_init(openresp, MPIDI_CH3I_PKT_SC_OPEN_RESP); 1208: #####: 943: openresp->ack = FALSE; 1360: -: 1065:int MPIDI_CH3I_VC_post_sockconnect(MPIDI_VC_t * vc) 1361: function MPIDI_CH3I_VC_post_sockconnect called 0 returned 0% blocks executed 0% 1362: #####: 1066:{ 1363: #####: 1067: int mpi_errno = MPI_SUCCESS; 1364: -: 1068: char val[MPIDI_MAX_KVS_VALUE_LEN]; 1365: #####: 1069: MPIDI_CH3I_VC *vcch = (MPIDI_CH3I_VC *)vc->channel_private; 1372: -: 1076: * obtain the ConnString by setting the VC to *CONNECTING. 1373: -: 1077: */ 1374: #####: 1078: if(vcch->state == MPIDI_CH3I_VC_STATE_UNCONNECTED){ 1376: branch 1 never executed 1377: -: 1079: MPIU_DBG_VCCHSTATECHANGE(vc,VC_STATE_CONNECTING); 1378: #####: 1080: vcch->state = MPIDI_CH3I_VC_STATE_CONNECTING; 1402: -: 1104: * discarding one of the connections 1403: -: 1105: */ 1404: #####: 1106: mpi_errno = MPI_SUCCESS; 1405: #####: 1107: goto fn_exit; 1406: -: 1108: } 1407: #####: 1109: mpi_errno = MPIDI_PG_GetConnString( vc->pg, vc->pg_rank, val, sizeof(val)); 1408: call 0 never executed 1409: #####: 1110: if (mpi_errno != MPI_SUCCESS) { 1414: -: 1112: } 1415: -: 1113: 1416: #####: 1114: mpi_errno = MPIDI_CH3I_Sock_connect( vc, val, sizeof(val) ); 1417: call 0 never executed 1418: -: 1115: 1419: #####: 1116: fn_exit: 1420: #####: 1116: fn_exit: 1421: #####: 1118: return mpi_errno; 1469: -: 1163: * discarding one of the connections 1470: -: 1164: */ 1471: #####: 1165: mpi_errno = MPI_SUCCESS; 1472: #####: 1166: goto fn_exit; 1507: -: 1191:#endif 1508: -: 1192: { 1509: #####: 1193: mpi_errno = MPIDU_Sock_post_connect(MPIDI_CH3I_sock_set, conn, 29 line(s) not covered by tests in src/mpid/ch3/util/sock/ch3u_connect_sock.c.gcov Uncovered lines in src/mpid/ch3/util/sock/ch3u_getinterfaces.c.gcov 102: -: 88: environment to each process */ 103: -: 89: char namebuf[1024]; 104: #####: 90: MPIU_Snprintf( namebuf, sizeof(namebuf), 105: call 0 never executed 106: -: 91: "MPICH_INTERFACE_HOSTNAME_R%d", myRank ); 107: #####: 92: ifname_string = getenv( namebuf ); 108: call 0 never executed 109: #####: 93: if (dbg_ifname && ifname_string) { 110: branch 0 never executed 111: branch 1 never executed 112: #####: 94: fprintf( stdout, "Found interface name %s from %s\n", 113: call 0 never executed 114: -: 95: ifname_string, namebuf ); 115: #####: 96: fflush( stdout ); 120: branch 0 taken 0% (fallthrough) 121: branch 1 taken 100% 122: #####: 100: fprintf( stdout, 124: -: 101: "Found interface name %s from MPICH_INTERFACE_HOSTNAME\n", 125: -: 102: ifname_string ); 126: #####: 103: fflush( stdout ); 134: -: 108: 135: -: 109: /* If we have nothing, then use the host name */ 136: #####: 110: mpi_errno = MPID_Get_processor_name(ifname, maxIfname, &len ); 140: branch 1 never executed 141: call 2 never executed 142: #####: 112: ifname_string = ifname; 146: -: 116: this platform. Otherwise, we'll drop into the next step that uses 147: -: 117: the ifname */ 148: #####: 118: mpi_errno = MPIDI_CH3U_GetIPInterface( ifaddr, &ifaddrFound ); 180: -: 136: /* If the address won't fit in the field, reset to 181: -: 137: no address */ 182: #####: 138: ifaddr->len = 0; 183: #####: 139: ifaddr->type = -1; 437: -: 368:static int MPIDI_CH3U_GetIPInterface( MPIDU_Sock_ifaddr_t *ifaddr, int *found ) 438: function MPIDI_CH3U_GetIPInterface called 0 returned 0% blocks executed 0% 439: #####: 369:{ 440: #####: 370: *found = 0; 441: #####: 371: return 0; 15 line(s) not covered by tests in src/mpid/ch3/util/sock/ch3u_getinterfaces.c.gcov All code covered by tests in src/mpid/ch3/util/sock/mpiimpl.h.gcov Uncovered lines in src/pmi/simple/simple_pmiutil.c.gcov 64: -: 57:void PMIU_SetServer( void ) 65: function PMIU_SetServer called 0 returned 0% blocks executed 0% 66: #####: 58:{ 67: #####: 59: MPIU_Strncpy( PMIU_print_id, "server", PMIU_IDSIZE ); 93: branch 1 taken 100% 94: -: 79: char filename[1024]; 95: #####: 80: p = getenv("PMI_ID"); 96: call 0 never executed 97: #####: 81: if (p) { 98: branch 0 never executed 99: branch 1 never executed 100: #####: 82: MPIU_Snprintf( filename, sizeof(filename), 101: call 0 never executed 102: -: 83: "testclient-%s.out", p ); 103: #####: 84: logfile = fopen( filename, "w" ); 105: -: 85: } 106: -: 86: else { 107: #####: 87: logfile = fopen( "testserver.out", "w" ); 157: branch 2 never executed 158: branch 3 never executed 159: #####: 126: MPIU_Internal_error_printf( "Panic - buffer inconsistent\n" ); 160: call 0 never executed 161: #####: 127: return -1; 184: branch 1 taken 100% 185: -: 139: /* EOF */ 186: #####: 140: break; 192: -: 144: data. Save the errno in case we need to return it 193: -: 145: later. */ 194: #####: 146: lastErrno = errno; 195: call 0 never executed 196: #####: 147: if (curlen == 1) { 197: branch 0 never executed 198: branch 1 never executed 199: #####: 148: curlen = 0; 235: branch 0 taken 0% (fallthrough) 236: branch 1 taken 100% 237: #####: 180: buf[PMIU_MAXLINE-1] = '\0'; 238: #####: 181: PMIU_printf( 1, "write_line: message string too big: :%s:\n", buf ); 243: branch 1 taken 0% (fallthrough) 244: branch 2 taken 100% 245: #####: 184: PMIU_printf( 1, "write_line: message string doesn't end in newline: :%s:\n", 260: branch 0 taken 0% (fallthrough) 261: branch 1 taken 100% 262: #####: 192: PMIU_printf( 1, "write_line error; fd=%d buf=:%s:\n", fd, buf ); 263: call 0 never executed 264: #####: 193: perror("system msg for write_line failure "); 265: call 0 never executed 266: #####: 194: return(-1); 269: branch 0 taken 0% (fallthrough) 270: branch 1 taken 100% 271: #####: 197: PMIU_printf( 1, "write_line failed to write entire message\n" ); 288: branch 0 taken 0% (fallthrough) 289: branch 1 taken 100% 290: #####: 212: return( -1 ); 301: branch 0 taken 0% (fallthrough) 302: branch 1 taken 100% 303: #####: 221: PMIU_printf( 1, "PMIU_parse_keyvals: unexpected = at character %d in %s\n", 304: call 0 never executed 305: -: 222: p - st, st ); 306: #####: 223: return( -1 ); 309: branch 0 taken 0% (fallthrough) 310: branch 1 taken 100% 311: #####: 226: return( 0 ); /* normal exit */ 325: branch 2 taken 0% (fallthrough) 326: branch 3 taken 100% 327: #####: 232: PMIU_printf( 1, 329: -: 233: "PMIU_parse_keyvals: unexpected key delimiter at character %d in %s\n", 330: -: 234: p - st, st ); 331: #####: 235: return( -1 ); 368: -: 262:void PMIU_dump_keyvals( void ) 369: function PMIU_dump_keyvals called 0 returned 0% blocks executed 0% 370: #####: 263:{ 371: -: 264: int i; 372: #####: 265: for (i=0; i < PMIU_keyval_tab_idx; i++) 373: branch 0 never executed 374: branch 1 never executed 375: #####: 266: PMIU_printf(1, " %s=%s\n",PMIU_keyval_tab[i].key, PMIU_keyval_tab[i].value); 394: branch 0 taken 0% (fallthrough) 395: branch 1 taken 100% 396: #####: 277: PMIU_printf( 1, "MPIU_Strncpy failed in PMIU_getval\n" ); 397: call 0 never executed 398: #####: 278: return NULL; 401: -: 281: } 402: -: 282: } 403: #####: 283: valstr[0] = '\0'; 404: #####: 284: return NULL; 407: -: 287:void PMIU_chgval( const char *keystr, char *valstr ) 408: function PMIU_chgval called 0 returned 0% blocks executed 0% 409: #####: 288:{ 410: -: 289: int i; 411: -: 290: 412: #####: 291: for ( i = 0; i < PMIU_keyval_tab_idx; i++ ) { 413: branch 0 never executed 414: branch 1 never executed 415: #####: 292: if ( strcmp( keystr, PMIU_keyval_tab[i].key ) == 0 ) { 417: branch 1 never executed 418: branch 2 never executed 419: #####: 293: MPIU_Strncpy( PMIU_keyval_tab[i].value, valstr, MAXVALLEN - 1 ); 420: call 0 never executed 421: #####: 294: PMIU_keyval_tab[i].value[MAXVALLEN - 1] = '\0'; 38 line(s) not covered by tests in src/pmi/simple/simple_pmiutil.c.gcov Uncovered lines in src/pmi/simple/simple_pmi.c.gcov 152: branch 0 taken 0% (fallthrough) 153: branch 1 taken 100% 154: #####: 140: return rc; 160: -: 144: /* Singleton init: Process not started with mpiexec, 161: -: 145: so set size to 1, rank to 0 */ 162: #####: 146: PMI_size = 1; 163: #####: 147: PMI_rank = 0; 164: #####: 148: *spawned = 0; 165: -: 149: 166: #####: 150: PMI_initialized = SINGLETON_INIT_BUT_NO_PM; 167: -: 151: /* 256 is picked as the minimum allowed length by the PMI servers */ 168: #####: 152: PMI_kvsname_max = 256; 169: #####: 153: PMI_keylen_max = 256; 170: #####: 154: PMI_vallen_max = 256; 171: -: 155: 172: #####: 156: return( 0 ); 185: call 0 returned 100% 186: -: 164: else 187: #####: 165: PMI_size = 1; 199: -: 172: } 200: -: 173: else 201: #####: 174: PMI_rank = 0; 208: call 0 returned 100% 209: -: 178: else 210: #####: 179: PMI_debug = 0; 231: -: 194: /* FIXME: And it most ceratainly should not happen *before* the 232: -: 195: initialization handshake */ 233: #####: 196: PMIU_readline( PMI_fd, buf, PMIU_MAXLINE ); 234: call 0 never executed 235: #####: 197: PMIU_parse_keyvals( buf ); 236: call 0 never executed 237: #####: 198: PMIU_getval( "cmd", cmd, PMIU_MAXLINE ); 238: call 0 never executed 239: #####: 199: if ( strncmp( cmd, "tv_ready", PMIU_MAXLINE ) != 0 ) { 249: branch 9 never executed 250: branch 10 never executed 251: #####: 200: PMIU_printf( 1, "expecting cmd=tv_ready, got %s\n", buf ); 252: call 0 never executed 253: #####: 201: return( PMI_FAIL ); 268: call 0 returned 100% 269: -: 212: else 270: #####: 213: PMI_spawned = 0; 286: -: 225:int PMI_Initialized( PMI_BOOL *initialized ) 287: function PMI_Initialized called 0 returned 0% blocks executed 0% 288: #####: 226:{ 291: -: 229: an PMI service (e.g., via mpiexec) and the singleton init, 292: -: 230: which has no PMI service */ 293: #####: 231: *initialized = PMI_initialized != 0 ? PMI_TRUE : PMI_FALSE; 294: #####: 232: return PMI_SUCCESS; 303: 9819: 238: *size = PMI_size; 304: -: 239: else 305: #####: 240: *size = 1; 315: 3273: 247: *rank = PMI_rank; 316: -: 248: else 317: #####: 249: *rank = 0; 351: 5: 272: return( PMI_SUCCESS ); 352: -: 273: } 353: #####: 274: else return err; 354: -: 275: } 355: -: 276: else 356: #####: 277: *size = 1; 357: #####: 278: return( PMI_SUCCESS ); 378: 3273: 291: return( PMI_SUCCESS ); 379: -: 292: } 380: #####: 293: else return err; 382: -: 295: } 383: -: 296: else 384: #####: 297: *appnum = -1; 385: -: 298: 386: #####: 299: return( PMI_SUCCESS ); 442: branch 0 taken 0% (fallthrough) 443: branch 1 taken 100% 444: #####: 337: char *p = buf, *p0; 445: -: 338: /* Allocate clique_ranks and fill it in */ 446: #####: 339: PMIU_getval( "value", buf, PMIU_MAXLINE ); 447: call 0 never executed 448: -: 340: /* Count the number of ranks and allocate the space for them */ 449: #####: 341: clique_size = 1; 450: #####: 342: while (*p) { 451: branch 0 never executed 452: branch 1 never executed 453: #####: 343: if (*p++ == ',') clique_size++; 455: branch 1 never executed 456: -: 344: } 457: #####: 345: clique_ranks = (int *)MPIU_Malloc( clique_size * sizeof(int) ); 458: call 0 never executed 459: -: 346: DBG_PRINTF( ("Clique_size = %d\n", clique_size) ); 460: #####: 347: p0 = p = buf; 461: #####: 348: i = 0; 462: #####: 349: while (*p) { 463: branch 0 never executed 464: branch 1 never executed 465: #####: 350: while (*p && *p != ',') p++; 466: branch 0 never executed 467: branch 1 never executed 468: #####: 351: if (*p == ',') *p++ = 0; 469: branch 0 never executed 470: branch 1 never executed 471: #####: 352: clique_ranks[i++] = atoi(p0); 472: call 0 never executed 473: #####: 353: p0 = p; 498: branch 0 taken 0% (fallthrough) 499: branch 1 taken 100% 500: #####: 375: return PMI_ERR_INVALID_ARG; 505: branch 2 taken 0% (fallthrough) 506: branch 3 taken 100% 507: #####: 378: for (i=0; i= 0) *v3 = *v3 + 1; 5 line(s) not covered by tests in src/binding/f77/waitanyf.c.gcov Uncovered lines in src/binding/f77/testanyf.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_testany__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_testany_ ( MPI_Fint *v1, MPI_Fint *v2, MPI_Fint *v3, MPI_Fint *v4, MPI_Fint *v5, MPI_Fint *ierr ){ 201: -: 195:#endif 202: -: 196: 203: #####: 197: if (v5 == MPI_F_STATUS_IGNORE) { v5 = (MPI_Fint*)MPI_STATUS_IGNORE; } 204: branch 0 never executed 205: branch 1 never executed 206: #####: 198: *ierr = MPI_Testany( *v1, (MPI_Request *)(v2), &l3, &l4, (MPI_Status *)v5 ); 207: call 0 never executed 208: #####: 199: *v3 = (MPI_Fint)l3; 209: #####: 200: if (l3 >= 0) *v3 = *v3 + 1; 210: branch 0 never executed 211: branch 1 never executed 212: #####: 201: *v4 = MPIR_TO_FLOG(l4); 6 line(s) not covered by tests in src/binding/f77/testanyf.c.gcov All code covered by tests in src/binding/f77/waitallf.c.gcov Uncovered lines in src/binding/f77/testallf.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_testall__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_testall_ ( MPI_Fint *v1, MPI_Fint *v2, MPI_Fint *v3, MPI_Fint *v4, MPI_Fint *ierr ){ 200: -: 194:#endif 201: -: 195: 202: #####: 196: if (v4 == MPI_F_STATUSES_IGNORE) { v4 = (MPI_Fint *)MPI_STATUSES_IGNORE; } 203: branch 0 never executed 204: branch 1 never executed 205: #####: 197: *ierr = MPI_Testall( *v1, (MPI_Request *)(v2), &l3, (MPI_Status *)v4 ); 206: call 0 never executed 207: #####: 198: *v3 = MPIR_TO_FLOG(l3); 4 line(s) not covered by tests in src/binding/f77/testallf.c.gcov Uncovered lines in src/binding/f77/waitsomef.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_waitsome__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_waitsome_ ( MPI_Fint *v1, MPI_Fint *v2, MPI_Fint *v3, MPI_Fint *v4, MPI_Fint *v5, MPI_Fint *ierr ){ 199: -: 193:#endif 200: -: 194: 201: #####: 195: if (v5 == MPI_F_STATUSES_IGNORE) { v5 = (MPI_Fint *)MPI_STATUSES_IGNORE; } 202: branch 0 never executed 203: branch 1 never executed 204: #####: 196: *ierr = MPI_Waitsome( *v1, (MPI_Request *)(v2), v3, v4, (MPI_Status *)v5 ); 206: -: 197: 207: -: 198: {int li; 208: #####: 199: for (li=0; li<*v3; li++) { 209: branch 0 never executed 210: branch 1 never executed 211: #####: 200: if (v4[li] >= 0) v4[li] += 1; 5 line(s) not covered by tests in src/binding/f77/waitsomef.c.gcov Uncovered lines in src/binding/f77/testsomef.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_testsome__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_testsome_ ( MPI_Fint *v1, MPI_Fint *v2, MPI_Fint *v3, MPI_Fint *v4, MPI_Fint *v5, MPI_Fint *ierr ){ 199: -: 193:#endif 200: -: 194: 201: #####: 195: if (v5 == MPI_F_STATUSES_IGNORE) { v5 = (MPI_Fint *)MPI_STATUSES_IGNORE; } 202: branch 0 never executed 203: branch 1 never executed 204: #####: 196: *ierr = MPI_Testsome( *v1, (MPI_Request *)(v2), v3, v4, (MPI_Status *)v5 ); 206: -: 197: 207: -: 198: {int li; 208: #####: 199: for (li=0; li<*v3; li++) { 209: branch 0 never executed 210: branch 1 never executed 211: #####: 200: if (v4[li] >= 0) v4[li] += 1; 5 line(s) not covered by tests in src/binding/f77/testsomef.c.gcov Uncovered lines in src/binding/f77/iprobef.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_iprobe__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_iprobe_ ( MPI_Fint *v1, MPI_Fint *v2, MPI_Fint *v3, MPI_Fint *v4, MPI_Fint *v5, MPI_Fint *ierr ){ 200: -: 194:#endif 201: -: 195: 202: #####: 196: if (v5 == MPI_F_STATUS_IGNORE) { v5 = (MPI_Fint*)MPI_STATUS_IGNORE; } 203: branch 0 never executed 204: branch 1 never executed 205: #####: 197: *ierr = MPI_Iprobe( *v1, *v2, (MPI_Comm)(*v3), &l4, (MPI_Status *)v5 ); 206: call 0 never executed 207: #####: 198: *v4 = MPIR_TO_FLOG(l4); 4 line(s) not covered by tests in src/binding/f77/iprobef.c.gcov Uncovered lines in src/binding/f77/probef.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_probe__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_probe_ ( MPI_Fint *v1, MPI_Fint *v2, MPI_Fint *v3, MPI_Fint *v4, MPI_Fint *ierr ){ 199: -: 193:#endif 200: -: 194: 201: #####: 195: if (v4 == MPI_F_STATUS_IGNORE) { v4 = (MPI_Fint*)MPI_STATUS_IGNORE; } 202: branch 0 never executed 203: branch 1 never executed 204: #####: 196: *ierr = MPI_Probe( *v1, *v2, (MPI_Comm)(*v3), (MPI_Status *)v4 ); 3 line(s) not covered by tests in src/binding/f77/probef.c.gcov All code covered by tests in src/binding/f77/cancelf.c.gcov Uncovered lines in src/binding/f77/testcancelf.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_test_cancelled__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_test_cancelled_ ( MPI_Fint *v1, MPI_Fint *v2, MPI_Fint *ierr ){ 196: -: 190: int l2; 197: #####: 191: *ierr = MPI_Test_cancelled( (MPI_Status *)(v1), &l2 ); 198: call 0 never executed 199: #####: 192: *v2 = MPIR_TO_FLOG(l2); 3 line(s) not covered by tests in src/binding/f77/testcancelf.c.gcov Uncovered lines in src/binding/f77/send_initf.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_send_init__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_send_init_ ( void*v1, MPI_Fint *v2, MPI_Fint *v3, MPI_Fint *v4, MPI_Fint *v5, MPI_Fint *v6, MPI_Fint *v7, MPI_Fint *ierr ){ 196: #####: 190: *ierr = MPI_Send_init( v1, *v2, (MPI_Datatype)(*v3), *v4, *v5, (MPI_Comm)(*v6), (MPI_Request *)(v7) ); 2 line(s) not covered by tests in src/binding/f77/send_initf.c.gcov Uncovered lines in src/binding/f77/bsend_initf.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_bsend_init__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_bsend_init_ ( void*v1, MPI_Fint *v2, MPI_Fint *v3, MPI_Fint *v4, MPI_Fint *v5, MPI_Fint *v6, MPI_Fint *v7, MPI_Fint *ierr ){ 196: #####: 190: *ierr = MPI_Bsend_init( v1, *v2, (MPI_Datatype)(*v3), *v4, *v5, (MPI_Comm)(*v6), (MPI_Request *)(v7) ); 2 line(s) not covered by tests in src/binding/f77/bsend_initf.c.gcov Uncovered lines in src/binding/f77/ssend_initf.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_ssend_init__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_ssend_init_ ( void*v1, MPI_Fint *v2, MPI_Fint *v3, MPI_Fint *v4, MPI_Fint *v5, MPI_Fint *v6, MPI_Fint *v7, MPI_Fint *ierr ){ 196: #####: 190: *ierr = MPI_Ssend_init( v1, *v2, (MPI_Datatype)(*v3), *v4, *v5, (MPI_Comm)(*v6), (MPI_Request *)(v7) ); 2 line(s) not covered by tests in src/binding/f77/ssend_initf.c.gcov Uncovered lines in src/binding/f77/rsend_initf.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_rsend_init__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_rsend_init_ ( void*v1, MPI_Fint *v2, MPI_Fint *v3, MPI_Fint *v4, MPI_Fint *v5, MPI_Fint *v6, MPI_Fint *v7, MPI_Fint *ierr ){ 196: #####: 190: *ierr = MPI_Rsend_init( v1, *v2, (MPI_Datatype)(*v3), *v4, *v5, (MPI_Comm)(*v6), (MPI_Request *)(v7) ); 2 line(s) not covered by tests in src/binding/f77/rsend_initf.c.gcov Uncovered lines in src/binding/f77/recv_initf.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_recv_init__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_recv_init_ ( void*v1, MPI_Fint *v2, MPI_Fint *v3, MPI_Fint *v4, MPI_Fint *v5, MPI_Fint *v6, MPI_Fint *v7, MPI_Fint *ierr ){ 196: #####: 190: *ierr = MPI_Recv_init( v1, *v2, (MPI_Datatype)(*v3), *v4, *v5, (MPI_Comm)(*v6), (MPI_Request *)(v7) ); 2 line(s) not covered by tests in src/binding/f77/recv_initf.c.gcov Uncovered lines in src/binding/f77/startf.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_start__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_start_ ( MPI_Fint *v1, MPI_Fint *ierr ){ 196: #####: 190: *ierr = MPI_Start( (MPI_Request *)(v1) ); 2 line(s) not covered by tests in src/binding/f77/startf.c.gcov Uncovered lines in src/binding/f77/startallf.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_startall__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_startall_ ( MPI_Fint *v1, MPI_Fint *v2, MPI_Fint *ierr ){ 196: #####: 190: *ierr = MPI_Startall( *v1, (MPI_Request *)(v2) ); 2 line(s) not covered by tests in src/binding/f77/startallf.c.gcov All code covered by tests in src/binding/f77/sendrecvf.c.gcov Uncovered lines in src/binding/f77/sndrcvrplf.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_sendrecv_replace__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_sendrecv_replace_ ( void*v1, MPI_Fint *v2, MPI_Fint *v3, MPI_Fint *v4, MPI_Fint *v5, MPI_Fint *v6, MPI_Fint *v7, MPI_Fint *v8, MPI_Fint *v9, MPI_Fint *ierr ){ 199: -: 193:#endif 200: -: 194: 201: #####: 195: if (v9 == MPI_F_STATUS_IGNORE) { v9 = (MPI_Fint*)MPI_STATUS_IGNORE; } 202: branch 0 never executed 203: branch 1 never executed 204: #####: 196: *ierr = MPI_Sendrecv_replace( v1, *v2, (MPI_Datatype)(*v3), *v4, *v5, *v6, *v7, (MPI_Comm)(*v8), (MPI_Status *)v9 ); 3 line(s) not covered by tests in src/binding/f77/sndrcvrplf.c.gcov Uncovered lines in src/binding/f77/typecontigf.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_type_contiguous__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_type_contiguous_ ( MPI_Fint *v1, MPI_Fint *v2, MPI_Fint *v3, MPI_Fint *ierr ){ 196: #####: 190: *ierr = MPI_Type_contiguous( *v1, (MPI_Datatype)(*v2), (MPI_Datatype *)(v3) ); 2 line(s) not covered by tests in src/binding/f77/typecontigf.c.gcov All code covered by tests in src/binding/f77/type_vectorf.c.gcov Uncovered lines in src/binding/f77/type_hvectorf.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_type_hvector__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_type_hvector_ ( MPI_Fint *v1, MPI_Fint *v2, MPI_Fint * v3, MPI_Fint *v4, MPI_Fint *v5, MPI_Fint *ierr ){ 196: -: 190: MPI_Aint l3; 197: #####: 191: l3 = (MPI_Aint)*v3; 198: #####: 192: *ierr = MPI_Type_hvector( *v1, *v2, l3, (MPI_Datatype)(*v4), (MPI_Datatype *)(v5) ); 3 line(s) not covered by tests in src/binding/f77/type_hvectorf.c.gcov All code covered by tests in src/binding/f77/type_indexedf.c.gcov Uncovered lines in src/binding/f77/type_hindexedf.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_type_hindexed__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_type_hindexed_ ( MPI_Fint *v1, MPI_Fint *v2, MPI_Fint * v3, MPI_Fint *v4, MPI_Fint *v5, MPI_Fint *ierr ){ 205: -: 199: else l3 = 0; 206: -: 200:#else 207: #####: 201: l3 = v3; 208: -: 202:#endif 209: #####: 203: *ierr = MPI_Type_hindexed( *v1, v2, l3, (MPI_Datatype)(*v4), (MPI_Datatype *)(v5) ); 3 line(s) not covered by tests in src/binding/f77/type_hindexedf.c.gcov Uncovered lines in src/binding/f77/type_structf.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_type_struct__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_type_struct_ ( MPI_Fint *v1, MPI_Fint *v2, MPI_Fint * v3, MPI_Fint *v4, MPI_Fint *v5, MPI_Fint *ierr ){ 205: -: 199: else l3 = 0; 206: -: 200:#else 207: #####: 201: l3 = v3; 208: -: 202:#endif 209: #####: 203: *ierr = MPI_Type_struct( *v1, v2, l3, (MPI_Datatype *)(v4), (MPI_Datatype *)(v5) ); 3 line(s) not covered by tests in src/binding/f77/type_structf.c.gcov Uncovered lines in src/binding/f77/type_extentf.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_type_extent__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_type_extent_ ( MPI_Fint *v1, MPI_Fint * v2, MPI_Fint *ierr ){ 196: -: 190: MPI_Aint l2; 197: #####: 191: *ierr = MPI_Type_extent( (MPI_Datatype)(*v1), &l2 ); 198: call 0 never executed 199: #####: 192: *v2 = (MPI_Fint)(l2); 3 line(s) not covered by tests in src/binding/f77/type_extentf.c.gcov All code covered by tests in src/binding/f77/type_sizef.c.gcov Uncovered lines in src/binding/f77/type_lbf.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_type_lb__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_type_lb_ ( MPI_Fint *v1, MPI_Fint * v2, MPI_Fint *ierr ){ 196: -: 190: MPI_Aint l2; 197: #####: 191: *ierr = MPI_Type_lb( (MPI_Datatype)(*v1), &l2 ); 198: call 0 never executed 199: #####: 192: *v2 = (MPI_Fint)(l2); 3 line(s) not covered by tests in src/binding/f77/type_lbf.c.gcov Uncovered lines in src/binding/f77/type_ubf.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_type_ub__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_type_ub_ ( MPI_Fint *v1, MPI_Fint * v2, MPI_Fint *ierr ){ 196: -: 190: MPI_Aint l2; 197: #####: 191: *ierr = MPI_Type_ub( (MPI_Datatype)(*v1), &l2 ); 198: call 0 never executed 199: #####: 192: *v2 = (MPI_Fint)(l2); 3 line(s) not covered by tests in src/binding/f77/type_ubf.c.gcov All code covered by tests in src/binding/f77/type_commitf.c.gcov All code covered by tests in src/binding/f77/type_freef.c.gcov Uncovered lines in src/binding/f77/get_elementsf.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_get_elements__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_get_elements_ ( MPI_Fint *v1, MPI_Fint *v2, MPI_Fint *v3, MPI_Fint *ierr ){ 196: #####: 190: *ierr = MPI_Get_elements( (MPI_Status *)(v1), (MPI_Datatype)(*v2), v3 ); 2 line(s) not covered by tests in src/binding/f77/get_elementsf.c.gcov Uncovered lines in src/binding/f77/packf.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_pack__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_pack_ ( void*v1, MPI_Fint *v2, MPI_Fint *v3, void*v4, MPI_Fint *v5, MPI_Fint *v6, MPI_Fint *v7, MPI_Fint *ierr ){ 196: #####: 190: *ierr = MPI_Pack( v1, *v2, (MPI_Datatype)(*v3), v4, *v5, v6, (MPI_Comm)(*v7) ); 2 line(s) not covered by tests in src/binding/f77/packf.c.gcov All code covered by tests in src/binding/f77/unpackf.c.gcov Uncovered lines in src/binding/f77/pack_sizef.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_pack_size__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_pack_size_ ( MPI_Fint *v1, MPI_Fint *v2, MPI_Fint *v3, MPI_Fint *v4, MPI_Fint *ierr ){ 196: #####: 190: *ierr = MPI_Pack_size( *v1, (MPI_Datatype)(*v2), (MPI_Comm)(*v3), v4 ); 2 line(s) not covered by tests in src/binding/f77/pack_sizef.c.gcov All code covered by tests in src/binding/f77/barrierf.c.gcov Uncovered lines in src/binding/f77/bcastf.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_bcast__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_bcast_ ( void*v1, MPI_Fint *v2, MPI_Fint *v3, MPI_Fint *v4, MPI_Fint *v5, MPI_Fint *ierr ){ 196: #####: 190: *ierr = MPI_Bcast( v1, *v2, (MPI_Datatype)(*v3), *v4, (MPI_Comm)(*v5) ); 2 line(s) not covered by tests in src/binding/f77/bcastf.c.gcov All code covered by tests in src/binding/f77/gatherf.c.gcov All code covered by tests in src/binding/f77/gathervf.c.gcov All code covered by tests in src/binding/f77/scatterf.c.gcov Uncovered lines in src/binding/f77/scattervf.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_scatterv__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_scatterv_ ( void*v1, MPI_Fint *v2, MPI_Fint *v3, MPI_Fint *v4, void*v5, MPI_Fint *v6, MPI_Fint *v7, MPI_Fint *v8, MPI_Fint *v9, MPI_Fint *ierr ){ 198: -: 192: if (MPIR_F_NeedInit){ mpirinitf_(); MPIR_F_NeedInit = 0; } 199: -: 193:#endif 200: #####: 194: if (v5 == MPIR_F_MPI_IN_PLACE) v5 = MPI_IN_PLACE; 201: branch 0 never executed 202: branch 1 never executed 203: #####: 195: *ierr = MPI_Scatterv( v1, v2, v3, (MPI_Datatype)(*v4), v5, *v6, (MPI_Datatype)(*v7), *v8, (MPI_Comm)(*v9) ); 3 line(s) not covered by tests in src/binding/f77/scattervf.c.gcov Uncovered lines in src/binding/f77/allgatherf.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_allgather__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_allgather_ ( void*v1, MPI_Fint *v2, MPI_Fint *v3, void*v4, MPI_Fint *v5, MPI_Fint *v6, MPI_Fint *v7, MPI_Fint *ierr ){ 198: -: 192: if (MPIR_F_NeedInit){ mpirinitf_(); MPIR_F_NeedInit = 0; } 199: -: 193:#endif 200: #####: 194: if (v1 == MPIR_F_MPI_IN_PLACE) v1 = MPI_IN_PLACE; 201: branch 0 never executed 202: branch 1 never executed 203: #####: 195: *ierr = MPI_Allgather( v1, *v2, (MPI_Datatype)(*v3), v4, *v5, (MPI_Datatype)(*v6), (MPI_Comm)(*v7) ); 3 line(s) not covered by tests in src/binding/f77/allgatherf.c.gcov Uncovered lines in src/binding/f77/allgathervf.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_allgatherv__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_allgatherv_ ( void*v1, MPI_Fint *v2, MPI_Fint *v3, void*v4, MPI_Fint *v5, MPI_Fint *v6, MPI_Fint *v7, MPI_Fint *v8, MPI_Fint *ierr ){ 198: -: 192: if (MPIR_F_NeedInit){ mpirinitf_(); MPIR_F_NeedInit = 0; } 199: -: 193:#endif 200: #####: 194: if (v1 == MPIR_F_MPI_IN_PLACE) v1 = MPI_IN_PLACE; 201: branch 0 never executed 202: branch 1 never executed 203: #####: 195: *ierr = MPI_Allgatherv( v1, *v2, (MPI_Datatype)(*v3), v4, v5, v6, (MPI_Datatype)(*v7), (MPI_Comm)(*v8) ); 3 line(s) not covered by tests in src/binding/f77/allgathervf.c.gcov Uncovered lines in src/binding/f77/alltoallf.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_alltoall__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_alltoall_ ( void*v1, MPI_Fint *v2, MPI_Fint *v3, void*v4, MPI_Fint *v5, MPI_Fint *v6, MPI_Fint *v7, MPI_Fint *ierr ){ 196: #####: 190: *ierr = MPI_Alltoall( v1, *v2, (MPI_Datatype)(*v3), v4, *v5, (MPI_Datatype)(*v6), (MPI_Comm)(*v7) ); 2 line(s) not covered by tests in src/binding/f77/alltoallf.c.gcov Uncovered lines in src/binding/f77/alltoallvf.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_alltoallv__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_alltoallv_ ( void*v1, MPI_Fint *v2, MPI_Fint *v3, MPI_Fint *v4, void*v5, MPI_Fint *v6, MPI_Fint *v7, MPI_Fint *v8, MPI_Fint *v9, MPI_Fint *ierr ){ 196: #####: 190: *ierr = MPI_Alltoallv( v1, v2, v3, (MPI_Datatype)(*v4), v5, v6, v7, (MPI_Datatype)(*v8), (MPI_Comm)(*v9) ); 2 line(s) not covered by tests in src/binding/f77/alltoallvf.c.gcov All code covered by tests in src/binding/f77/reducef.c.gcov All code covered by tests in src/binding/f77/op_createf.c.gcov All code covered by tests in src/binding/f77/op_freef.c.gcov All code covered by tests in src/binding/f77/allreducef.c.gcov Uncovered lines in src/binding/f77/redscatf.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_reduce_scatter__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_reduce_scatter_ ( void*v1, void*v2, MPI_Fint *v3, MPI_Fint *v4, MPI_Fint *v5, MPI_Fint *v6, MPI_Fint *ierr ){ 198: -: 192: if (MPIR_F_NeedInit){ mpirinitf_(); MPIR_F_NeedInit = 0; } 199: -: 193:#endif 200: #####: 194: if (v1 == MPIR_F_MPI_IN_PLACE) v1 = MPI_IN_PLACE; 201: branch 0 never executed 202: branch 1 never executed 203: #####: 195: *ierr = MPI_Reduce_scatter( v1, v2, v3, (MPI_Datatype)(*v4), *v5, (MPI_Comm)(*v6) ); 3 line(s) not covered by tests in src/binding/f77/redscatf.c.gcov Uncovered lines in src/binding/f77/scanf.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_scan__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_scan_ ( void*v1, void*v2, MPI_Fint *v3, MPI_Fint *v4, MPI_Fint *v5, MPI_Fint *v6, MPI_Fint *ierr ){ 198: -: 192: if (MPIR_F_NeedInit){ mpirinitf_(); MPIR_F_NeedInit = 0; } 199: -: 193:#endif 200: #####: 194: if (v1 == MPIR_F_MPI_IN_PLACE) v1 = MPI_IN_PLACE; 201: branch 0 never executed 202: branch 1 never executed 203: #####: 195: *ierr = MPI_Scan( v1, v2, *v3, (MPI_Datatype)(*v4), *v5, (MPI_Comm)(*v6) ); 3 line(s) not covered by tests in src/binding/f77/scanf.c.gcov All code covered by tests in src/binding/f77/group_sizef.c.gcov All code covered by tests in src/binding/f77/group_rankf.c.gcov Uncovered lines in src/binding/f77/grouptranksf.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_group_translate_ranks__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_group_translate_ranks_ ( MPI_Fint *v1, MPI_Fint *v2, MPI_Fint *v3, MPI_Fint *v4, MPI_Fint *v5, MPI_Fint *ierr ){ 196: #####: 190: *ierr = MPI_Group_translate_ranks( *v1, *v2, v3, *v4, v5 ); 2 line(s) not covered by tests in src/binding/f77/grouptranksf.c.gcov All code covered by tests in src/binding/f77/group_comparef.c.gcov All code covered by tests in src/binding/f77/comm_groupf.c.gcov Uncovered lines in src/binding/f77/group_unionf.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_group_union__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_group_union_ ( MPI_Fint *v1, MPI_Fint *v2, MPI_Fint *v3, MPI_Fint *ierr ){ 196: #####: 190: *ierr = MPI_Group_union( *v1, *v2, v3 ); 2 line(s) not covered by tests in src/binding/f77/group_unionf.c.gcov Uncovered lines in src/binding/f77/groupinterf.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_group_intersection__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_group_intersection_ ( MPI_Fint *v1, MPI_Fint *v2, MPI_Fint *v3, MPI_Fint *ierr ){ 196: #####: 190: *ierr = MPI_Group_intersection( *v1, *v2, v3 ); 2 line(s) not covered by tests in src/binding/f77/groupinterf.c.gcov Uncovered lines in src/binding/f77/groupdifff.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_group_difference__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_group_difference_ ( MPI_Fint *v1, MPI_Fint *v2, MPI_Fint *v3, MPI_Fint *ierr ){ 196: #####: 190: *ierr = MPI_Group_difference( *v1, *v2, v3 ); 2 line(s) not covered by tests in src/binding/f77/groupdifff.c.gcov All code covered by tests in src/binding/f77/group_inclf.c.gcov Uncovered lines in src/binding/f77/group_exclf.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_group_excl__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_group_excl_ ( MPI_Fint *v1, MPI_Fint *v2, MPI_Fint *v3, MPI_Fint *v4, MPI_Fint *ierr ){ 196: #####: 190: *ierr = MPI_Group_excl( *v1, *v2, v3, v4 ); 2 line(s) not covered by tests in src/binding/f77/group_exclf.c.gcov Uncovered lines in src/binding/f77/grouprinclf.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_group_range_incl__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_group_range_incl_ ( MPI_Fint *v1, MPI_Fint *v2, MPI_Fint v3[], MPI_Fint *v4, MPI_Fint *ierr ){ 196: #####: 190: *ierr = MPI_Group_range_incl( *v1, *v2, (int (*)[3])(v3), v4 ); 2 line(s) not covered by tests in src/binding/f77/grouprinclf.c.gcov Uncovered lines in src/binding/f77/grouprexclf.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_group_range_excl__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_group_range_excl_ ( MPI_Fint *v1, MPI_Fint *v2, MPI_Fint v3[], MPI_Fint *v4, MPI_Fint *ierr ){ 196: #####: 190: *ierr = MPI_Group_range_excl( *v1, *v2, (int (*)[3])(v3), v4 ); 2 line(s) not covered by tests in src/binding/f77/grouprexclf.c.gcov All code covered by tests in src/binding/f77/group_freef.c.gcov All code covered by tests in src/binding/f77/comm_sizef.c.gcov All code covered by tests in src/binding/f77/comm_rankf.c.gcov Uncovered lines in src/binding/f77/comm_comparef.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_comm_compare__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_comm_compare_ ( MPI_Fint *v1, MPI_Fint *v2, MPI_Fint *v3, MPI_Fint *ierr ){ 196: #####: 190: *ierr = MPI_Comm_compare( (MPI_Comm)(*v1), (MPI_Comm)(*v2), v3 ); 2 line(s) not covered by tests in src/binding/f77/comm_comparef.c.gcov All code covered by tests in src/binding/f77/comm_dupf.c.gcov Uncovered lines in src/binding/f77/comm_createf.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_comm_create__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_comm_create_ ( MPI_Fint *v1, MPI_Fint *v2, MPI_Fint *v3, MPI_Fint *ierr ){ 196: #####: 190: *ierr = MPI_Comm_create( (MPI_Comm)(*v1), *v2, (MPI_Comm *)(v3) ); 2 line(s) not covered by tests in src/binding/f77/comm_createf.c.gcov All code covered by tests in src/binding/f77/comm_splitf.c.gcov All code covered by tests in src/binding/f77/comm_freef.c.gcov Uncovered lines in src/binding/f77/commtesticf.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_comm_test_inter__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_comm_test_inter_ ( MPI_Fint *v1, MPI_Fint *v2, MPI_Fint *ierr ){ 196: -: 190: int l2; 197: #####: 191: *ierr = MPI_Comm_test_inter( (MPI_Comm)(*v1), &l2 ); 198: call 0 never executed 199: #####: 192: *v2 = MPIR_TO_FLOG(l2); 3 line(s) not covered by tests in src/binding/f77/commtesticf.c.gcov All code covered by tests in src/binding/f77/commrsizef.c.gcov Uncovered lines in src/binding/f77/commrgroupf.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_comm_remote_group__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_comm_remote_group_ ( MPI_Fint *v1, MPI_Fint *v2, MPI_Fint *ierr ){ 196: #####: 190: *ierr = MPI_Comm_remote_group( (MPI_Comm)(*v1), v2 ); 2 line(s) not covered by tests in src/binding/f77/commrgroupf.c.gcov Uncovered lines in src/binding/f77/iccreatef.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_intercomm_create__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_intercomm_create_ ( MPI_Fint *v1, MPI_Fint *v2, MPI_Fint *v3, MPI_Fint *v4, MPI_Fint *v5, MPI_Fint *v6, MPI_Fint *ierr ){ 196: #####: 190: *ierr = MPI_Intercomm_create( (MPI_Comm)(*v1), *v2, (MPI_Comm)(*v3), *v4, *v5, (MPI_Comm *)(v6) ); 2 line(s) not covered by tests in src/binding/f77/iccreatef.c.gcov Uncovered lines in src/binding/f77/icmergef.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_intercomm_merge__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_intercomm_merge_ ( MPI_Fint *v1, MPI_Fint *v2, MPI_Fint *v3, MPI_Fint *ierr ){ 196: -: 190: int l2; 197: #####: 191: l2 = MPIR_FROM_FLOG(*v2); 198: #####: 192: *ierr = MPI_Intercomm_merge( (MPI_Comm)(*v1), l2, (MPI_Comm *)(v3) ); 3 line(s) not covered by tests in src/binding/f77/icmergef.c.gcov Uncovered lines in src/binding/f77/keyval_freef.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_keyval_free__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_keyval_free_ ( MPI_Fint *v1, MPI_Fint *ierr ){ 196: #####: 190: *ierr = MPI_Keyval_free( v1 ); 2 line(s) not covered by tests in src/binding/f77/keyval_freef.c.gcov Uncovered lines in src/binding/f77/attr_putf.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_attr_put__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_attr_put_ ( MPI_Fint *v1, MPI_Fint *v2, void*v3, MPI_Fint *ierr ){ 196: #####: 190: *ierr = MPIR_CommSetAttr( (MPI_Comm)(*v1), *v2, (void *)(MPIR_Pint)((int)*(int *)v3), MPIR_ATTR_INT ); 2 line(s) not covered by tests in src/binding/f77/attr_putf.c.gcov Uncovered lines in src/binding/f77/attr_getf.c.gcov 204: branch 2 taken 0% (fallthrough) 205: branch 3 taken 100% 206: #####: 195: *(MPI_Fint*)v3 = 0; 1 line(s) not covered by tests in src/binding/f77/attr_getf.c.gcov Uncovered lines in src/binding/f77/attr_deletef.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_attr_delete__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_attr_delete_ ( MPI_Fint *v1, MPI_Fint *v2, MPI_Fint *ierr ){ 196: #####: 190: *ierr = MPI_Attr_delete( (MPI_Comm)(*v1), *v2 ); 2 line(s) not covered by tests in src/binding/f77/attr_deletef.c.gcov Uncovered lines in src/binding/f77/topo_testf.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_topo_test__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_topo_test_ ( MPI_Fint *v1, MPI_Fint *v2, MPI_Fint *ierr ){ 196: #####: 190: *ierr = MPI_Topo_test( (MPI_Comm)(*v1), v2 ); 2 line(s) not covered by tests in src/binding/f77/topo_testf.c.gcov All code covered by tests in src/binding/f77/cart_createf.c.gcov All code covered by tests in src/binding/f77/dims_createf.c.gcov Uncovered lines in src/binding/f77/graph_createf.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_graph_create__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_graph_create_ ( MPI_Fint *v1, MPI_Fint *v2, MPI_Fint *v3, MPI_Fint *v4, MPI_Fint *v5, MPI_Fint *v6, MPI_Fint *ierr ){ 196: #####: 190: *ierr = MPI_Graph_create( (MPI_Comm)(*v1), *v2, v3, v4, *v5, (MPI_Comm *)(v6) ); 2 line(s) not covered by tests in src/binding/f77/graph_createf.c.gcov Uncovered lines in src/binding/f77/graphdims_getf.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_graphdims_get__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_graphdims_get_ ( MPI_Fint *v1, MPI_Fint *v2, MPI_Fint *v3, MPI_Fint *ierr ){ 196: #####: 190: *ierr = MPI_Graphdims_get( (MPI_Comm)(*v1), v2, v3 ); 2 line(s) not covered by tests in src/binding/f77/graphdims_getf.c.gcov Uncovered lines in src/binding/f77/graph_getf.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_graph_get__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_graph_get_ ( MPI_Fint *v1, MPI_Fint *v2, MPI_Fint *v3, MPI_Fint *v4, MPI_Fint *v5, MPI_Fint *ierr ){ 196: #####: 190: *ierr = MPI_Graph_get( (MPI_Comm)(*v1), *v2, *v3, v4, v5 ); 2 line(s) not covered by tests in src/binding/f77/graph_getf.c.gcov Uncovered lines in src/binding/f77/cartdim_getf.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_cartdim_get__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_cartdim_get_ ( MPI_Fint *v1, MPI_Fint *v2, MPI_Fint *ierr ){ 196: #####: 190: *ierr = MPI_Cartdim_get( (MPI_Comm)(*v1), v2 ); 2 line(s) not covered by tests in src/binding/f77/cartdim_getf.c.gcov All code covered by tests in src/binding/f77/cart_getf.c.gcov Uncovered lines in src/binding/f77/cart_rankf.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_cart_rank__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_cart_rank_ ( MPI_Fint *v1, MPI_Fint *v2, MPI_Fint *v3, MPI_Fint *ierr ){ 196: #####: 190: *ierr = MPI_Cart_rank( (MPI_Comm)(*v1), v2, v3 ); 2 line(s) not covered by tests in src/binding/f77/cart_rankf.c.gcov Uncovered lines in src/binding/f77/cart_coordsf.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_cart_coords__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_cart_coords_ ( MPI_Fint *v1, MPI_Fint *v2, MPI_Fint *v3, MPI_Fint *v4, MPI_Fint *ierr ){ 196: #####: 190: *ierr = MPI_Cart_coords( (MPI_Comm)(*v1), *v2, *v3, v4 ); 2 line(s) not covered by tests in src/binding/f77/cart_coordsf.c.gcov Uncovered lines in src/binding/f77/grfnbcountf.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_graph_neighbors_count__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_graph_neighbors_count_ ( MPI_Fint *v1, MPI_Fint *v2, MPI_Fint *v3, MPI_Fint *ierr ){ 196: #####: 190: *ierr = MPI_Graph_neighbors_count( (MPI_Comm)(*v1), *v2, v3 ); 2 line(s) not covered by tests in src/binding/f77/grfnbcountf.c.gcov Uncovered lines in src/binding/f77/grfnbrsf.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_graph_neighbors__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_graph_neighbors_ ( MPI_Fint *v1, MPI_Fint *v2, MPI_Fint *v3, MPI_Fint *v4, MPI_Fint *ierr ){ 196: #####: 190: *ierr = MPI_Graph_neighbors( (MPI_Comm)(*v1), *v2, *v3, v4 ); 2 line(s) not covered by tests in src/binding/f77/grfnbrsf.c.gcov All code covered by tests in src/binding/f77/cart_shiftf.c.gcov Uncovered lines in src/binding/f77/cart_subf.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_cart_sub__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_cart_sub_ ( MPI_Fint *v1, MPI_Fint *v2, MPI_Fint *v3, MPI_Fint *ierr ){ 196: #####: 190: *ierr = MPI_Cart_sub( (MPI_Comm)(*v1), v2, (MPI_Comm *)(v3) ); 2 line(s) not covered by tests in src/binding/f77/cart_subf.c.gcov Uncovered lines in src/binding/f77/cart_mapf.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_cart_map__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_cart_map_ ( MPI_Fint *v1, MPI_Fint *v2, MPI_Fint *v3, MPI_Fint *v4, MPI_Fint *v5, MPI_Fint *ierr ){ 196: #####: 190: *ierr = MPI_Cart_map( (MPI_Comm)(*v1), *v2, v3, v4, v5 ); 2 line(s) not covered by tests in src/binding/f77/cart_mapf.c.gcov Uncovered lines in src/binding/f77/graph_mapf.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_graph_map__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_graph_map_ ( MPI_Fint *v1, MPI_Fint *v2, MPI_Fint *v3, MPI_Fint *v4, MPI_Fint *v5, MPI_Fint *ierr ){ 196: #####: 190: *ierr = MPI_Graph_map( (MPI_Comm)(*v1), *v2, v3, v4, v5 ); 2 line(s) not covered by tests in src/binding/f77/graph_mapf.c.gcov Uncovered lines in src/binding/f77/getpnamef.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_get_processor_name__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_get_processor_name_ ( char *v1 FORT_MIXED_LEN(d1), MPI_Fint *v2, MPI_Fint *ierr FORT_END_LEN(d1) ){ 196: -: 190: char *p1; 197: #####: 191: p1 = (char *)MPIU_Malloc( d1 + 1 ); 198: call 0 never executed 199: #####: 192: *ierr = MPI_Get_processor_name( p1, v2 ); 200: call 0 never executed 201: -: 193: 202: #####: 194: {char *p = v1, *pc=p1; 203: #####: 195: while (*pc) {*p++ = *pc++;} 204: branch 0 never executed 205: branch 1 never executed 206: #####: 196: while ((p-v1) < d1) { *p++ = ' '; } 208: branch 1 never executed 209: -: 197: } 210: #####: 198: MPIU_Free( p1 ); 7 line(s) not covered by tests in src/binding/f77/getpnamef.c.gcov All code covered by tests in src/binding/f77/get_versionf.c.gcov Uncovered lines in src/binding/f77/errhcreatef.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_errhandler_create__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_errhandler_create_ ( MPI_Handler_function*v1, MPI_Fint *v2, MPI_Fint *ierr ){ 196: #####: 190: *ierr = MPI_Errhandler_create( v1, v2 ); 2 line(s) not covered by tests in src/binding/f77/errhcreatef.c.gcov Uncovered lines in src/binding/f77/errhsetf.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_errhandler_set__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_errhandler_set_ ( MPI_Fint *v1, MPI_Fint *v2, MPI_Fint *ierr ){ 196: #####: 190: *ierr = MPI_Errhandler_set( (MPI_Comm)(*v1), *v2 ); 2 line(s) not covered by tests in src/binding/f77/errhsetf.c.gcov Uncovered lines in src/binding/f77/errhgetf.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_errhandler_get__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_errhandler_get_ ( MPI_Fint *v1, MPI_Fint *v2, MPI_Fint *ierr ){ 196: #####: 190: *ierr = MPI_Errhandler_get( (MPI_Comm)(*v1), v2 ); 2 line(s) not covered by tests in src/binding/f77/errhgetf.c.gcov All code covered by tests in src/binding/f77/errhfreef.c.gcov All code covered by tests in src/binding/f77/error_stringf.c.gcov All code covered by tests in src/binding/f77/error_classf.c.gcov All code covered by tests in src/binding/f77/finalizef.c.gcov All code covered by tests in src/binding/f77/initializedf.c.gcov Uncovered lines in src/binding/f77/abortf.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_abort__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_abort_ ( MPI_Fint *v1, MPI_Fint *v2, MPI_Fint *ierr ){ 196: #####: 190: *ierr = MPI_Abort( (MPI_Comm)(*v1), *v2 ); 2 line(s) not covered by tests in src/binding/f77/abortf.c.gcov All code covered by tests in src/binding/f77/close_portf.c.gcov All code covered by tests in src/binding/f77/comm_acceptf.c.gcov All code covered by tests in src/binding/f77/comm_connectf.c.gcov All code covered by tests in src/binding/f77/commdiscf.c.gcov All code covered by tests in src/binding/f77/commparentf.c.gcov Uncovered lines in src/binding/f77/comm_joinf.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_comm_join__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_comm_join_ ( MPI_Fint *v1, MPI_Fint *v2, MPI_Fint *ierr ){ 196: #####: 190: *ierr = MPI_Comm_join( *v1, (MPI_Comm *)(v2) ); 2 line(s) not covered by tests in src/binding/f77/comm_joinf.c.gcov All code covered by tests in src/binding/f77/comm_spawnf.c.gcov All code covered by tests in src/binding/f77/spawnmultf.c.gcov All code covered by tests in src/binding/f77/lookup_namef.c.gcov All code covered by tests in src/binding/f77/open_portf.c.gcov All code covered by tests in src/binding/f77/publish_namef.c.gcov All code covered by tests in src/binding/f77/unpubnamef.c.gcov All code covered by tests in src/binding/f77/accumulatef.c.gcov All code covered by tests in src/binding/f77/getf.c.gcov All code covered by tests in src/binding/f77/putf.c.gcov All code covered by tests in src/binding/f77/win_completef.c.gcov All code covered by tests in src/binding/f77/win_createf.c.gcov All code covered by tests in src/binding/f77/win_fencef.c.gcov All code covered by tests in src/binding/f77/win_freef.c.gcov All code covered by tests in src/binding/f77/win_get_groupf.c.gcov Uncovered lines in src/binding/f77/win_lockf.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_win_lock__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_win_lock_ ( MPI_Fint *v1, MPI_Fint *v2, MPI_Fint *v3, MPI_Fint *v4, MPI_Fint *ierr ){ 196: #####: 190: *ierr = MPI_Win_lock( *v1, *v2, *v3, *v4 ); 2 line(s) not covered by tests in src/binding/f77/win_lockf.c.gcov All code covered by tests in src/binding/f77/win_postf.c.gcov All code covered by tests in src/binding/f77/win_startf.c.gcov All code covered by tests in src/binding/f77/win_testf.c.gcov Uncovered lines in src/binding/f77/win_unlockf.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_win_unlock__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_win_unlock_ ( MPI_Fint *v1, MPI_Fint *v2, MPI_Fint *ierr ){ 196: #####: 190: *ierr = MPI_Win_unlock( *v1, *v2 ); 2 line(s) not covered by tests in src/binding/f77/win_unlockf.c.gcov All code covered by tests in src/binding/f77/win_waitf.c.gcov All code covered by tests in src/binding/f77/alltoallwf.c.gcov All code covered by tests in src/binding/f77/exscanf.c.gcov All code covered by tests in src/binding/f77/adderrclassf.c.gcov All code covered by tests in src/binding/f77/adderrcodef.c.gcov All code covered by tests in src/binding/f77/adderrstringf.c.gcov All code covered by tests in src/binding/f77/commcallerrf.c.gcov All code covered by tests in src/binding/f77/commnewkeyf.c.gcov All code covered by tests in src/binding/f77/commdelattrf.c.gcov All code covered by tests in src/binding/f77/commfreekeyf.c.gcov All code covered by tests in src/binding/f77/comm_get_attrf.c.gcov All code covered by tests in src/binding/f77/commgetnamf.c.gcov All code covered by tests in src/binding/f77/comm_set_attrf.c.gcov All code covered by tests in src/binding/f77/comm_set_namef.c.gcov All code covered by tests in src/binding/f77/filecallerrf.c.gcov All code covered by tests in src/binding/f77/greqcompletef.c.gcov All code covered by tests in src/binding/f77/greqstartf.c.gcov All code covered by tests in src/binding/f77/isthrmainf.c.gcov All code covered by tests in src/binding/f77/query_threadf.c.gcov All code covered by tests in src/binding/f77/statgetclf.c.gcov All code covered by tests in src/binding/f77/statsetelf.c.gcov All code covered by tests in src/binding/f77/typenewkeyf.c.gcov All code covered by tests in src/binding/f77/typedelattrf.c.gcov All code covered by tests in src/binding/f77/type_dupf.c.gcov All code covered by tests in src/binding/f77/typefreekeyf.c.gcov All code covered by tests in src/binding/f77/type_get_attrf.c.gcov All code covered by tests in src/binding/f77/typegetcntsf.c.gcov All code covered by tests in src/binding/f77/typegetenvf.c.gcov All code covered by tests in src/binding/f77/typegnamef.c.gcov All code covered by tests in src/binding/f77/typesetattrf.c.gcov All code covered by tests in src/binding/f77/typesetnamef.c.gcov Uncovered lines in src/binding/f77/type_match_sizef.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_type_match_size__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_type_match_size_ ( MPI_Fint *v1, MPI_Fint *v2, MPI_Fint *v3, MPI_Fint *ierr ){ 196: #####: 190: *ierr = MPI_Type_match_size( *v1, *v2, (MPI_Datatype *)(v3) ); 2 line(s) not covered by tests in src/binding/f77/type_match_sizef.c.gcov All code covered by tests in src/binding/f77/wincallerrf.c.gcov Uncovered lines in src/binding/f77/winnewkeyf.c.gcov 211: -: 206: ) 212: function MPIR_Win_copy_attr_f90_proxy called 0 returned 0% blocks executed 0% 213: #####: 207:{ 214: #####: 208: MPI_Fint ierr = 0; 215: #####: 209: MPI_Fint fhandle = (MPI_Fint)win; 216: #####: 210: MPI_Fint fkeyval = (MPI_Fint)keyval; 217: #####: 211: MPI_Aint fvalue = MPI_VOID_PTR_CAST_TO_MPI_AINT (value); 218: #####: 212: MPI_Aint* fextra = (MPI_Aint*)extra_state; 219: #####: 213: MPI_Aint fnew = 0; 220: #####: 214: MPI_Fint fflag = 0; 221: -: 215: 222: #####: 216: ((F90_CopyFunction*)user_function)( &fhandle, &fkeyval, fextra, &fvalue, &fnew, &fflag, &ierr ); 223: call 0 never executed 224: -: 217: 225: #####: 218: *flag = fflag; 226: #####: 219: *new_value = MPI_AINT_CAST_TO_VOID_PTR (fnew); 227: #####: 220: return ierr; 12 line(s) not covered by tests in src/binding/f77/winnewkeyf.c.gcov All code covered by tests in src/binding/f77/windelattrf.c.gcov All code covered by tests in src/binding/f77/winfreekeyf.c.gcov All code covered by tests in src/binding/f77/win_get_attrf.c.gcov All code covered by tests in src/binding/f77/win_get_namef.c.gcov All code covered by tests in src/binding/f77/win_set_attrf.c.gcov All code covered by tests in src/binding/f77/win_set_namef.c.gcov Uncovered lines in src/binding/f77/alloc_memf.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_alloc_mem__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_alloc_mem_ ( MPI_Aint * v1, MPI_Fint *v2, void*v3, MPI_Fint *ierr ){ 196: #####: 190: *ierr = MPI_Alloc_mem( *v1, (MPI_Info)(*v2), v3 ); 2 line(s) not covered by tests in src/binding/f77/alloc_memf.c.gcov All code covered by tests in src/binding/f77/commcreerrf.c.gcov All code covered by tests in src/binding/f77/commgeterrf.c.gcov All code covered by tests in src/binding/f77/commseterrf.c.gcov All code covered by tests in src/binding/f77/filecreerrf.c.gcov All code covered by tests in src/binding/f77/filegeterrf.c.gcov All code covered by tests in src/binding/f77/fileseterrf.c.gcov All code covered by tests in src/binding/f77/finalizedf.c.gcov Uncovered lines in src/binding/f77/free_memf.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_free_mem__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_free_mem_ ( void*v1, MPI_Fint *ierr ){ 196: #####: 190: *ierr = MPI_Free_mem( v1 ); 2 line(s) not covered by tests in src/binding/f77/free_memf.c.gcov All code covered by tests in src/binding/f77/info_createf.c.gcov All code covered by tests in src/binding/f77/info_deletef.c.gcov All code covered by tests in src/binding/f77/info_dupf.c.gcov All code covered by tests in src/binding/f77/info_freef.c.gcov All code covered by tests in src/binding/f77/info_getf.c.gcov All code covered by tests in src/binding/f77/infognkf.c.gcov All code covered by tests in src/binding/f77/infognthkf.c.gcov All code covered by tests in src/binding/f77/infovallenf.c.gcov All code covered by tests in src/binding/f77/info_setf.c.gcov All code covered by tests in src/binding/f77/pack_externalf.c.gcov All code covered by tests in src/binding/f77/packesizef.c.gcov Uncovered lines in src/binding/f77/reqgetstatf.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_request_get_status__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_request_get_status_ ( MPI_Fint *v1, MPI_Fint *v2, MPI_Fint *v3, MPI_Fint *ierr ){ 196: #####: 190: *ierr = MPI_Request_get_status( *v1, v2, (MPI_Status *)(v3) ); 2 line(s) not covered by tests in src/binding/f77/reqgetstatf.c.gcov Uncovered lines in src/binding/f77/typedarrayf.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_type_create_darray__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_type_create_darray_ ( MPI_Fint *v1, MPI_Fint *v2, MPI_Fint *v3, MPI_Fint v4[], MPI_Fint v5[], MPI_Fint v6[], MPI_Fint v7[], MPI_Fint *v8, MPI_Fint *v9, MPI_Fint *v10, MPI_Fint *ierr ){ 196: #####: 190: *ierr = MPI_Type_create_darray( *v1, *v2, *v3, v4, v5, v6, v7, *v8, (MPI_Datatype)(*v9), (MPI_Datatype *)(v10) ); 2 line(s) not covered by tests in src/binding/f77/typedarrayf.c.gcov All code covered by tests in src/binding/f77/typechindf.c.gcov All code covered by tests in src/binding/f77/typechvecf.c.gcov All code covered by tests in src/binding/f77/typecindbf.c.gcov All code covered by tests in src/binding/f77/typecresizef.c.gcov All code covered by tests in src/binding/f77/typecstructf.c.gcov All code covered by tests in src/binding/f77/typecsubarrf.c.gcov All code covered by tests in src/binding/f77/typegetextentf.c.gcov All code covered by tests in src/binding/f77/typegtextf.c.gcov All code covered by tests in src/binding/f77/unpackextf.c.gcov All code covered by tests in src/binding/f77/wincreerrf.c.gcov All code covered by tests in src/binding/f77/wingeterrf.c.gcov All code covered by tests in src/binding/f77/winseterrf.c.gcov All code covered by tests in src/binding/f77/reduce_localf.c.gcov Uncovered lines in src/binding/f77/op_commutativef.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_op_commutative__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_op_commutative_ ( MPI_Fint *v1, MPI_Fint *v2, MPI_Fint *ierr ){ 196: -: 190: int l2; 197: #####: 191: *ierr = MPI_Op_commutative( *v1, &l2 ); 198: call 0 never executed 199: #####: 192: *v2 = MPIR_TO_FLOG(l2); 3 line(s) not covered by tests in src/binding/f77/op_commutativef.c.gcov Uncovered lines in src/binding/f77/reduce_scatter_blockf.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_reduce_scatter_block__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_reduce_scatter_block_ ( void*v1, void*v2, MPI_Fint *v3, MPI_Fint *v4, MPI_Fint *v5, MPI_Fint *v6, MPI_Fint *ierr ){ 196: #####: 190: *ierr = MPI_Reduce_scatter_block( v1, v2, *v3, (MPI_Datatype)(*v4), *v5, (MPI_Comm)(*v6) ); 2 line(s) not covered by tests in src/binding/f77/reduce_scatter_blockf.c.gcov Uncovered lines in src/binding/f77/dist_graph_create_adjacentf.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_dist_graph_create_adjacent__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_dist_graph_create_adjacent_ ( MPI_Fint *v1, MPI_Fint *v2, MPI_Fint v3[], MPI_Fint v4[], MPI_Fint *v5, MPI_Fint v6[], MPI_Fint v7[], MPI_Fint *v8, MPI_Fint *v9, MPI_Fint *v10, MPI_Fint *ierr ){ 196: #####: 190: *ierr = MPI_Dist_graph_create_adjacent( (MPI_Comm)(*v1), *v2, v3, v4, *v5, v6, v7, (MPI_Info)(*v8), *v9, (MPI_Comm *)(v10) ); 2 line(s) not covered by tests in src/binding/f77/dist_graph_create_adjacentf.c.gcov Uncovered lines in src/binding/f77/dist_graph_createf.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_dist_graph_create__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_dist_graph_create_ ( MPI_Fint *v1, MPI_Fint *v2, MPI_Fint v3[], MPI_Fint v4[], MPI_Fint v5[], MPI_Fint v6[], MPI_Fint *v7, MPI_Fint *v8, MPI_Fint *v9, MPI_Fint *ierr ){ 196: #####: 190: *ierr = MPI_Dist_graph_create( (MPI_Comm)(*v1), *v2, v3, v4, v5, v6, (MPI_Info)(*v7), *v8, (MPI_Comm *)(v9) ); 2 line(s) not covered by tests in src/binding/f77/dist_graph_createf.c.gcov Uncovered lines in src/binding/f77/dist_graph_neighbors_countf.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_dist_graph_neighbors_count__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_dist_graph_neighbors_count_ ( MPI_Fint *v1, MPI_Fint *v2, MPI_Fint *v3, MPI_Fint *v4, MPI_Fint *ierr ){ 196: #####: 190: *ierr = MPI_Dist_graph_neighbors_count( (MPI_Comm)(*v1), v2, v3, v4 ); 2 line(s) not covered by tests in src/binding/f77/dist_graph_neighbors_countf.c.gcov Uncovered lines in src/binding/f77/dist_graph_neighborsf.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_dist_graph_neighbors__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_dist_graph_neighbors_ ( MPI_Fint *v1, MPI_Fint *v2, MPI_Fint v3[], MPI_Fint v4[], MPI_Fint *v5, MPI_Fint v6[], MPI_Fint v7[], MPI_Fint *ierr ){ 196: #####: 190: *ierr = MPI_Dist_graph_neighbors( (MPI_Comm)(*v1), *v2, v3, v4, *v5, v6, v7 ); 2 line(s) not covered by tests in src/binding/f77/dist_graph_neighborsf.c.gcov All code covered by tests in src/binding/f77/file_openf.c.gcov All code covered by tests in src/binding/f77/file_closef.c.gcov All code covered by tests in src/binding/f77/file_deletef.c.gcov All code covered by tests in src/binding/f77/file_set_sizef.c.gcov All code covered by tests in src/binding/f77/file_preallocatef.c.gcov All code covered by tests in src/binding/f77/file_get_sizef.c.gcov All code covered by tests in src/binding/f77/file_get_groupf.c.gcov All code covered by tests in src/binding/f77/file_get_amodef.c.gcov All code covered by tests in src/binding/f77/file_set_infof.c.gcov All code covered by tests in src/binding/f77/file_get_infof.c.gcov All code covered by tests in src/binding/f77/file_set_viewf.c.gcov All code covered by tests in src/binding/f77/file_get_viewf.c.gcov Uncovered lines in src/binding/f77/file_read_atf.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_file_read_at__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_file_read_at_ ( MPI_Fint *v1, MPI_Offset *v2, void*v3, MPI_Fint *v4, MPI_Fint *v5, MPI_Fint *v6, MPI_Fint *ierr ){ 196: -: 190:#ifdef MPI_MODE_RDONLY 197: #####: 191: *ierr = MPI_File_read_at( MPI_File_f2c(*v1), *v2, v3, *v4, (MPI_Datatype)(*v5), (MPI_Status *)(v6) ); 2 line(s) not covered by tests in src/binding/f77/file_read_atf.c.gcov Uncovered lines in src/binding/f77/file_read_at_allf.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_file_read_at_all__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_file_read_at_all_ ( MPI_Fint *v1, MPI_Offset *v2, void*v3, MPI_Fint *v4, MPI_Fint *v5, MPI_Fint *v6, MPI_Fint *ierr ){ 196: -: 190:#ifdef MPI_MODE_RDONLY 197: #####: 191: *ierr = MPI_File_read_at_all( MPI_File_f2c(*v1), *v2, v3, *v4, (MPI_Datatype)(*v5), (MPI_Status *)(v6) ); 2 line(s) not covered by tests in src/binding/f77/file_read_at_allf.c.gcov Uncovered lines in src/binding/f77/file_write_atf.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_file_write_at__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_file_write_at_ ( MPI_Fint *v1, MPI_Offset *v2, void*v3, MPI_Fint *v4, MPI_Fint *v5, MPI_Fint *v6, MPI_Fint *ierr ){ 196: -: 190:#ifdef MPI_MODE_RDONLY 197: #####: 191: *ierr = MPI_File_write_at( MPI_File_f2c(*v1), *v2, v3, *v4, (MPI_Datatype)(*v5), (MPI_Status *)(v6) ); 2 line(s) not covered by tests in src/binding/f77/file_write_atf.c.gcov Uncovered lines in src/binding/f77/file_write_at_allf.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_file_write_at_all__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_file_write_at_all_ ( MPI_Fint *v1, MPI_Offset *v2, void*v3, MPI_Fint *v4, MPI_Fint *v5, MPI_Fint *v6, MPI_Fint *ierr ){ 196: -: 190:#ifdef MPI_MODE_RDONLY 197: #####: 191: *ierr = MPI_File_write_at_all( MPI_File_f2c(*v1), *v2, v3, *v4, (MPI_Datatype)(*v5), (MPI_Status *)(v6) ); 2 line(s) not covered by tests in src/binding/f77/file_write_at_allf.c.gcov Uncovered lines in src/binding/f77/file_iread_atf.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_file_iread_at__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_file_iread_at_ ( MPI_Fint *v1, MPI_Offset *v2, void*v3, MPI_Fint *v4, MPI_Fint *v5, MPIO_Request*v6, MPI_Fint *ierr ){ 196: -: 190:#ifdef MPI_MODE_RDONLY 197: #####: 191: *ierr = MPI_File_iread_at( MPI_File_f2c(*v1), *v2, v3, *v4, (MPI_Datatype)(*v5), v6 ); 2 line(s) not covered by tests in src/binding/f77/file_iread_atf.c.gcov Uncovered lines in src/binding/f77/file_iwrite_atf.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_file_iwrite_at__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_file_iwrite_at_ ( MPI_Fint *v1, MPI_Offset *v2, void*v3, MPI_Fint *v4, MPI_Fint *v5, MPIO_Request*v6, MPI_Fint *ierr ){ 196: -: 190:#ifdef MPI_MODE_RDONLY 197: #####: 191: *ierr = MPI_File_iwrite_at( MPI_File_f2c(*v1), *v2, v3, *v4, (MPI_Datatype)(*v5), v6 ); 2 line(s) not covered by tests in src/binding/f77/file_iwrite_atf.c.gcov All code covered by tests in src/binding/f77/file_readf.c.gcov Uncovered lines in src/binding/f77/file_read_allf.c.gcov 193: -: 188:#include "fproto.h" 194: function pmpi_file_read_all__ called 0 returned 0% blocks executed 0% 195: #####: 189:FORT_DLL_SPEC void FORT_CALL mpi_file_read_all_ ( MPI_Fint *v1, void*v2, MPI_Fint *v3, MPI_Fint *v4, MPI_Fint *v5, MPI_Fint *ierr ){ 196: -: 190:#ifdef MPI_MODE_RDONLY 197: #####: 191: