int MPI_Finalize(void) { int result, MPIT_result; uint64_t * exchange_count_matrix = NULL; uint64_t * exchange_size_matrix = NULL; uint64_t * exchange_avg_size_matrix = NULL; if (0 == comm_world_rank) { exchange_count_matrix = (uint64_t *) malloc(comm_world_size * comm_world_size * sizeof(uint64_t)); exchange_size_matrix = (uint64_t *) malloc(comm_world_size * comm_world_size * sizeof(uint64_t)); exchange_avg_size_matrix = (uint64_t *) malloc(comm_world_size * comm_world_size * sizeof(uint64_t)); } stop_monitoring_result(&counts); stop_monitoring_result(&sizes); get_monitoring_result(&counts); get_monitoring_result(&sizes); PMPI_Gather(counts.vector, comm_world_size, MPI_UNSIGNED_LONG, exchange_count_matrix, comm_world_size, MPI_UNSIGNED_LONG, 0, MPI_COMM_WORLD); PMPI_Gather(sizes.vector, comm_world_size, MPI_UNSIGNED_LONG, exchange_size_matrix, comm_world_size, MPI_UNSIGNED_LONG, 0, MPI_COMM_WORLD); if (0 == comm_world_rank) { int i, j; //Get the same matrix than profile2mat.pl for (i = 0; i < comm_world_size; ++i) { for (j = i + 1; j < comm_world_size; ++j) { exchange_count_matrix[i * comm_world_size + j] = exchange_count_matrix[j * comm_world_size + i] = (exchange_count_matrix[i * comm_world_size + j] + exchange_count_matrix[j * comm_world_size + i]) / 2; exchange_size_matrix[i * comm_world_size + j] = exchange_size_matrix[j * comm_world_size + i] = (exchange_size_matrix[i * comm_world_size + j] + exchange_size_matrix[j * comm_world_size + i]) / 2; if (exchange_count_matrix[i * comm_world_size + j] != 0) exchange_avg_size_matrix[i * comm_world_size + j] = exchange_avg_size_matrix[j * comm_world_size + i] = exchange_size_matrix[i * comm_world_size + j] / exchange_count_matrix[i * comm_world_size + j]; } } write_mat("monitoring_msg.mat", exchange_count_matrix, comm_world_size); write_mat("monitoring_size.mat", exchange_size_matrix, comm_world_size); write_mat("monitoring_avg.mat", exchange_avg_size_matrix, comm_world_size); } free(exchange_count_matrix); free(exchange_size_matrix); free(exchange_avg_size_matrix); destroy_monitoring_result(&counts); destroy_monitoring_result(&sizes); MPIT_result = MPI_T_pvar_session_free(&session); if (MPIT_result != MPI_SUCCESS) { fprintf(stderr, "WARNING : failed to free MPI_T session, monitoring results may be impacted : check your OpenMPI installation\n"); } MPIT_result = MPI_T_finalize(); if (MPIT_result != MPI_SUCCESS) { fprintf(stderr, "WARNING : failed to finalize MPI_T interface, monitoring results may be impacted : check your OpenMPI installation\n"); } result = PMPI_Finalize(); return result; }
int main(int argc, char **argv) { int i; int num; int rank, size; /*#define STR_SZ (15)*/ #define STR_SZ (50) int name_len = STR_SZ; char name[STR_SZ] = ""; int desc_len = STR_SZ; char desc[STR_SZ] = ""; int verb; MPI_Datatype dtype; int count; int bind; int varclass; int readonly, continuous, atomic; int provided; MPI_T_enum enumtype; int pq_idx = -1, uq_idx = -1, pqm_idx = -1, uqm_idx = -1; int pqm_writable = -1, uqm_writable = -1; MPI_Init(&argc, &argv); MPI_Comm_rank(MPI_COMM_WORLD, &rank); MPI_Comm_size(MPI_COMM_WORLD, &size); provided = 0xdeadbeef; MPI_T_init_thread(MPI_THREAD_SINGLE, &provided); assert(provided != 0xdeadbeef); num = 0xdeadbeef; MPI_T_pvar_get_num(&num); printf("get_num=%d\n", num); assert(num != 0xdeadbeef); for (i = 0; i < num; ++i) { name_len = desc_len = STR_SZ; MPI_T_pvar_get_info(i, name, &name_len, &verb, &varclass, &dtype, &enumtype, desc, &desc_len, &bind, &readonly, &continuous, &atomic); printf("index=%d\n", i); printf("--> name='%s' name_len=%d desc='%s' desc_len=%d\n", name, name_len, desc, desc_len); printf("--> verb=%d varclass=%d dtype=%#x bind=%d readonly=%d continuous=%d atomic=%d\n", verb, varclass, dtype, bind, readonly, continuous, atomic); if (0 == strcmp(name, "posted_recvq_length")) { pq_idx = i; } else if (0 == strcmp(name, "unexpected_recvq_length")) { uq_idx = i; } else if (0 == strcmp(name, "posted_recvq_match_attempts")) { pqm_idx = i; pqm_writable = !readonly; } else if (0 == strcmp(name, "unexpected_recvq_match_attempts")) { uqm_idx = i; uqm_writable = !readonly; } } printf("pq_idx=%d uq_idx=%d pqm_idx=%d uqm_idx=%d\n", pq_idx, uq_idx, pqm_idx, uqm_idx); /* setup a session and handles for the PQ and UQ length variables */ session = MPI_T_PVAR_SESSION_NULL; MPI_T_pvar_session_create(&session); assert(session != MPI_T_PVAR_SESSION_NULL); pq_handle = MPI_T_PVAR_HANDLE_NULL; MPI_T_pvar_handle_alloc(session, pq_idx, NULL, &pq_handle, &count); assert(count = 1); assert(pq_handle != MPI_T_PVAR_HANDLE_NULL); uq_handle = MPI_T_PVAR_HANDLE_NULL; MPI_T_pvar_handle_alloc(session, uq_idx, NULL, &uq_handle, &count); assert(count = 1); assert(uq_handle != MPI_T_PVAR_HANDLE_NULL); pqm_handle = MPI_T_PVAR_HANDLE_NULL; MPI_T_pvar_handle_alloc(session, pqm_idx, NULL, &pqm_handle, &count); assert(count = 1); assert(pqm_handle != MPI_T_PVAR_HANDLE_NULL); uqm_handle = MPI_T_PVAR_HANDLE_NULL; MPI_T_pvar_handle_alloc(session, uqm_idx, NULL, &uqm_handle, &count); assert(count = 1); assert(uqm_handle != MPI_T_PVAR_HANDLE_NULL); /* now send/recv some messages and track the lengths of the queues */ { int buf1, buf2, buf3, buf4; MPI_Request r1, r2, r3, r4; buf1 = buf2 = buf3 = buf4 = 0xfeedface; r1 = r2 = r3 = r4 = MPI_REQUEST_NULL; posted_qlen = 0x0123abcd; unexpected_qlen = 0x0123abcd; posted_queue_match_attempts = 0x0123abcd; unexpected_queue_match_attempts = 0x0123abcd; print_vars(1); MPI_Isend(&buf1, 1, MPI_INT, 0, /*tag=*/11, MPI_COMM_SELF, &r1); print_vars(2); printf("expected (posted_qlen,unexpected_qlen) = (0,1)\n"); MPI_Isend(&buf1, 1, MPI_INT, 0, /*tag=*/22, MPI_COMM_SELF, &r2); print_vars(3); printf("expected (posted_qlen,unexpected_qlen) = (0,2)\n"); MPI_Irecv(&buf2, 1, MPI_INT, 0, /*tag=*/33, MPI_COMM_SELF, &r3); print_vars(4); printf("expected (posted_qlen,unexpected_qlen) = (1,2)\n"); MPI_Recv(&buf3, 1, MPI_INT, 0, /*tag=*/22, MPI_COMM_SELF, MPI_STATUS_IGNORE); MPI_Wait(&r2, MPI_STATUS_IGNORE); print_vars(5); printf("expected (posted_qlen,unexpected_qlen) = (1,1)\n"); MPI_Recv(&buf3, 1, MPI_INT, 0, /*tag=*/11, MPI_COMM_SELF, MPI_STATUS_IGNORE); MPI_Wait(&r1, MPI_STATUS_IGNORE); print_vars(6); printf("expected (posted_qlen,unexpected_qlen) = (1,0)\n"); MPI_Send(&buf3, 1, MPI_INT, 0, /*tag=*/33, MPI_COMM_SELF); MPI_Wait(&r3, MPI_STATUS_IGNORE); print_vars(7); printf("expected (posted_qlen,unexpected_qlen) = (0,0)\n"); } if (pqm_writable) { posted_queue_match_attempts = 0; MPI_T_pvar_write(session, pqm_handle, &posted_queue_match_attempts); } if (uqm_writable) { unexpected_queue_match_attempts = 0; MPI_T_pvar_write(session, uqm_handle, &unexpected_queue_match_attempts); } print_vars(8); /* cleanup */ MPI_T_pvar_handle_free(session, &uqm_handle); MPI_T_pvar_handle_free(session, &pqm_handle); MPI_T_pvar_handle_free(session, &uq_handle); MPI_T_pvar_handle_free(session, &pq_handle); MPI_T_pvar_session_free(&session); MPI_T_finalize(); MPI_Finalize(); return 0; }
int main(int argc, char* argv[]) { int rank, size, n, to, from, tagno, MPIT_result, provided, count; MPI_T_pvar_session session; MPI_Status status; MPI_Comm newcomm; MPI_Request request; char filename[1024]; /* first phase : make a token circulated in MPI_COMM_WORLD */ n = -1; MPI_Init(&argc, &argv); MPI_Comm_rank(MPI_COMM_WORLD, &rank); MPI_Comm_size(MPI_COMM_WORLD, &size); to = (rank + 1) % size; from = (rank - 1) % size; tagno = 201; MPIT_result = MPI_T_init_thread(MPI_THREAD_SINGLE, &provided); if (MPIT_result != MPI_SUCCESS) MPI_Abort(MPI_COMM_WORLD, MPIT_result); MPIT_result = MPI_T_pvar_get_index(flush_pvar_name, MPI_T_PVAR_CLASS_GENERIC, &flush_pvar_idx); if (MPIT_result != MPI_SUCCESS) { printf("cannot find monitoring MPI_T \"%s\" pvar, check that you have monitoring pml\n", flush_pvar_name); MPI_Abort(MPI_COMM_WORLD, MPIT_result); } MPIT_result = MPI_T_pvar_session_create(&session); if (MPIT_result != MPI_SUCCESS) { printf("cannot create a session for \"%s\" pvar\n", flush_pvar_name); MPI_Abort(MPI_COMM_WORLD, MPIT_result); } /* Allocating a new PVAR in a session will reset the counters */ MPIT_result = MPI_T_pvar_handle_alloc(session, flush_pvar_idx, MPI_COMM_WORLD, &flush_handle, &count); if (MPIT_result != MPI_SUCCESS) { printf("failed to allocate handle on \"%s\" pvar, check that you have monitoring pml\n", flush_pvar_name); MPI_Abort(MPI_COMM_WORLD, MPIT_result); } MPIT_result = MPI_T_pvar_start(session, flush_handle); if (MPIT_result != MPI_SUCCESS) { printf("failed to start handle on \"%s\" pvar, check that you have monitoring pml\n", flush_pvar_name); MPI_Abort(MPI_COMM_WORLD, MPIT_result); } if (rank == 0) { n = 25; MPI_Isend(&n,1,MPI_INT,to,tagno,MPI_COMM_WORLD,&request); } while (1) { MPI_Irecv(&n,1,MPI_INT,from,tagno,MPI_COMM_WORLD, &request); MPI_Wait(&request,&status); if (rank == 0) {n--;tagno++;} MPI_Isend(&n,1,MPI_INT,to,tagno,MPI_COMM_WORLD, &request); if (rank != 0) {n--;tagno++;} if (n<0){ break; } } /* Build one file per processes Every thing that has been monitored by each process since the last flush will be output in filename */ /* Requires directory prof to be created. Filename format should display the phase number and the process rank for ease of parsing with aggregate_profile.pl script */ sprintf(filename,"prof/phase_1_%d.prof",rank); if( MPI_SUCCESS != MPI_T_pvar_write(session, flush_handle, filename) ) { fprintf(stderr, "Process %d cannot save monitoring in %s\n", rank, filename); } /* Force the writing of the monitoring data */ MPIT_result = MPI_T_pvar_stop(session, flush_handle); if (MPIT_result != MPI_SUCCESS) { printf("failed to stop handle on \"%s\" pvar, check that you have monitoring pml\n", flush_pvar_name); MPI_Abort(MPI_COMM_WORLD, MPIT_result); } MPIT_result = MPI_T_pvar_start(session, flush_handle); if (MPIT_result != MPI_SUCCESS) { printf("failed to start handle on \"%s\" pvar, check that you have monitoring pml\n", flush_pvar_name); MPI_Abort(MPI_COMM_WORLD, MPIT_result); } /* Don't set a filename. If we stop the session before setting it, then no output ile * will be generated. */ if( MPI_SUCCESS != MPI_T_pvar_write(session, flush_handle, NULL) ) { fprintf(stderr, "Process %d cannot save monitoring in %s\n", rank, filename); } /* Second phase. Work with different communicators. even ranls will circulate a token while odd ranks wil perform a all_to_all */ MPI_Comm_split(MPI_COMM_WORLD, rank%2, rank, &newcomm); /* the filename for flushing monitoring now uses 2 as phase number! */ sprintf(filename, "prof/phase_2_%d.prof", rank); if(rank%2){ /*even ranks (in COMM_WORD) circulate a token*/ MPI_Comm_rank(newcomm, &rank); MPI_Comm_size(newcomm, &size); if( size > 1 ) { to = (rank + 1) % size;; from = (rank - 1) % size ; tagno = 201; if (rank == 0){ n = 50; MPI_Send(&n, 1, MPI_INT, to, tagno, newcomm); } while (1){ MPI_Recv(&n, 1, MPI_INT, from, tagno, newcomm, &status); if (rank == 0) {n--; tagno++;} MPI_Send(&n, 1, MPI_INT, to, tagno, newcomm); if (rank != 0) {n--; tagno++;} if (n<0){ if( MPI_SUCCESS != MPI_T_pvar_write(session, flush_handle, filename) ) { fprintf(stderr, "Process %d cannot save monitoring in %s\n", rank, filename); } break; } } } } else { /*odd ranks (in COMM_WORD) will perform a all_to_all and a barrier*/ int send_buff[10240]; int recv_buff[10240]; MPI_Comm_rank(newcomm, &rank); MPI_Comm_size(newcomm, &size); MPI_Alltoall(send_buff, 10240/size, MPI_INT, recv_buff, 10240/size, MPI_INT, newcomm); MPI_Comm_split(newcomm, rank%2, rank, &newcomm); MPI_Barrier(newcomm); if( MPI_SUCCESS != MPI_T_pvar_write(session, flush_handle, filename) ) { fprintf(stderr, "Process %d cannot save monitoring in %s\n", rank, filename); } } MPIT_result = MPI_T_pvar_stop(session, flush_handle); if (MPIT_result != MPI_SUCCESS) { printf("failed to stop handle on \"%s\" pvar, check that you have monitoring pml\n", flush_pvar_name); MPI_Abort(MPI_COMM_WORLD, MPIT_result); } MPIT_result = MPI_T_pvar_handle_free(session, &flush_handle); if (MPIT_result != MPI_SUCCESS) { printf("failed to free handle on \"%s\" pvar, check that you have monitoring pml\n", flush_pvar_name); MPI_Abort(MPI_COMM_WORLD, MPIT_result); } MPIT_result = MPI_T_pvar_session_free(&session); if (MPIT_result != MPI_SUCCESS) { printf("cannot close a session for \"%s\" pvar\n", flush_pvar_name); MPI_Abort(MPI_COMM_WORLD, MPIT_result); } (void)PMPI_T_finalize(); /* Now, in MPI_Finalize(), the pml_monitoring library outputs, in STDERR, the aggregated recorded monitoring of all the phases*/ MPI_Finalize(); return 0; }
int main(int argc, char *argv[]) { int i, size, num, name_len, desc_len, verb, thread_support; int varclass, bind, readonly, continuous, atomic, uqsize_idx, count; char name[STR_LEN], desc[STR_LEN]; MPI_Datatype dtype; MPI_T_enum enumtype; MPI_Init(NULL, NULL); MPI_Comm_size(MPI_COMM_WORLD, &size); MPI_Comm_rank(MPI_COMM_WORLD, &rank); if (rank == 0) { printf("MPIT pvar test: unexpected_recvq_buffer_size\n"); fflush(stdout); } /* Ensure we're using exactly two ranks. */ /* Future tests (using collectives) might need this because of the MPI_Barrier */ assert(size == 2); /* Standard MPIT initialization. */ TRY(MPI_T_init_thread(MPI_THREAD_SINGLE, &thread_support)); TRY(MPI_T_pvar_get_num(&num)); int found = 0; /* Locate desired MPIT variable. */ for (i = 0; i < num; i++) { name_len = desc_len = STR_LEN; TRY(MPI_T_pvar_get_info(i, name, &name_len, &verb, &varclass, &dtype, &enumtype, desc, &desc_len, &bind, &readonly, &continuous, &atomic)); if (strcmp(name, "unexpected_recvq_buffer_size") == 0) { uqsize_idx = i; found = 1; } } if (found) { /* Initialize MPIT session & variable handle. */ MPI_T_pvar_session_create(&session); MPI_T_pvar_handle_alloc(session, uqsize_idx, NULL, &uqsize_handle, &count); /* Ensure the variable is of the correct size. */ assert(count == 1); /* Run a batch of tests. */ reversed_tags_test(); rndv_test(); /* Cleanup. */ MPI_T_pvar_handle_free(session, &uqsize_handle); MPI_T_pvar_session_free(&session); } if (rank == 0) { printf("finished\n"); fflush(stdout); } TRY(MPI_T_finalize()); MPI_Finalize(); return 0; }