int MPI_Irecv(void *buf, int count, MPI_Datatype datatype, int source, int tag, MPI_Comm comm, MPI_Request *request) { /* creates a request */ int err; err=PMPI_Irecv(buf,count,datatype,source,tag,comm,request); return err; }
int MPI_Irecv(void* buffer, int count, MPI_Datatype datatype, int src, int tag, MPI_Comm comm, MPI_Request* request) { cqueue_t* mycqueue = handle_get_cqueue(comm); if (mycqueue != NULL) return cqueue_irecv(mycqueue, buffer, count, datatype, src, tag, comm, request); else { if (std_mpi_mode == STD_MPI_MODE_IMPLICIT && max_ep > 0) return cqueue_irecv(client_get_cqueue((taskid + src) % max_ep), buffer, count, datatype, src, tag, comm, request); return PMPI_Irecv(buffer, count, datatype, src, tag, comm, request); } }
static int MTCORE_Wait_pscw_complete_msg(int post_grp_size, MTCORE_Win * uh_win) { int mpi_errno = MPI_SUCCESS; int user_rank; int i; char post_flg; MPI_Request *reqs = NULL; MPI_Status *stats = NULL; int remote_cnt = 0; reqs = calloc(post_grp_size, sizeof(MPI_Request)); stats = calloc(post_grp_size, sizeof(MPI_Status)); PMPI_Comm_rank(uh_win->user_comm, &user_rank); for (i = 0; i < post_grp_size; i++) { int origin_rank = uh_win->post_ranks_in_win_group[i]; /* Do not receive from local target, otherwise it may deadlock. * We do not check the wrong sync case that user calls start(self) * before/without post(self). */ if (user_rank == origin_rank) continue; mpi_errno = PMPI_Irecv(&post_flg, 1, MPI_CHAR, origin_rank, MTCORE_PSCW_CW_TAG, uh_win->user_comm, &reqs[remote_cnt++]); if (mpi_errno != MPI_SUCCESS) goto fn_fail; MTCORE_DBG_PRINT("receive pscw complete msg from target %d \n", origin_rank); } /* It is blocking. */ mpi_errno = PMPI_Waitall(remote_cnt, reqs, stats); if (mpi_errno != MPI_SUCCESS) goto fn_fail; fn_exit: if (reqs) free(reqs); if (stats) free(stats); return mpi_errno; fn_fail: goto fn_exit; }
int MPI_Recv_Nospin( void* buff, const int count, MPI_Datatype datatype, const int from, const int tag, MPI_Comm comm, MPI_Status* status ) { MPI_Request req; PMPI_Irecv( buff, count, datatype, from, tag, comm, &req ); timespec ts{ 0, nsec_start }; int flag = 0; while ( !flag ) { nanosleep( &ts, nullptr ); ts.tv_nsec = std::min( size_t(ts.tv_nsec << 1), nsec_max ); PMPI_Request_get_status( req, &flag, status ); } return status->MPI_ERROR; }
int MPI_Irecv(void *buf, int count, MPI_Datatype datatype, int source, int tag, MPI_Comm comm, MPI_Request *request) { int returnVal; request_list *newrq1; returnVal = PMPI_Irecv( buf, count, datatype, source, tag, comm, request ); if (source != MPI_PROC_NULL && returnVal == MPI_SUCCESS) { rq_alloc( requests_avail_1, newrq1 ); if (newrq1) { newrq1->request = *request; newrq1->status = RQ_RECV; newrq1->next = 0; rq_add( requests_head_1, requests_tail_1, newrq1 ); } } return returnVal; }
int main(int argc, char** argv) { MPI_Init(&argc, &argv); int rank, peer, commsize; MPI_Comm_rank(MPI_COMM_WORLD, &rank); MPI_Comm_size(MPI_COMM_WORLD, &commsize); if (rank % 2) peer = rank - 1 % commsize; else peer = rank + 1 % commsize; if (commsize % 2 != 0) { fprintf(stderr, "Use even number of processes.\n"); exit(EXIT_FAILURE); } char* mpi_inbuf; char* mpi_outbuf; char* pmpi_inbuf; char* pmpi_outbuf; test_start("isend/irecv + test (2, vector[[int], count=2, blklen=3, stride=5])"); init_buffers(20*sizeof(int), &mpi_inbuf, &pmpi_inbuf, &mpi_outbuf, &pmpi_outbuf); MPI_Datatype vector_ddt; MPI_Type_vector(2, 3, 5, MPI_INT, &vector_ddt); MPI_Type_commit(&vector_ddt); MPI_Datatype pmpi_vector_ddt; PMPI_Type_vector(2, 3, 5, MPI_INT, &pmpi_vector_ddt); PMPI_Type_commit(&pmpi_vector_ddt); MPI_Request requests_mpi[2]; MPI_Request requests_pmpi[2]; MPI_Status statuses_mpi[2]; MPI_Status statuses_pmpi[2]; if (rank % 2 == 0) { MPI_Isend(mpi_inbuf, 2, vector_ddt, peer, 0, MPI_COMM_WORLD, &(requests_mpi[0])); MPI_Irecv(mpi_outbuf, 2, vector_ddt, peer, 0, MPI_COMM_WORLD, &(requests_mpi[1])); PMPI_Isend(pmpi_inbuf, 2, pmpi_vector_ddt, peer, 0, MPI_COMM_WORLD, &(requests_pmpi[0])); PMPI_Irecv(pmpi_outbuf, 2, pmpi_vector_ddt, peer, 0, MPI_COMM_WORLD, &(requests_pmpi[1])); } else { MPI_Irecv(mpi_outbuf, 2, vector_ddt, peer, 0, MPI_COMM_WORLD, &(requests_mpi[0])); MPI_Isend(mpi_inbuf, 2, vector_ddt, peer, 0, MPI_COMM_WORLD, &(requests_mpi[1])); PMPI_Irecv(pmpi_outbuf, 2, pmpi_vector_ddt, peer, 0, MPI_COMM_WORLD, &(requests_pmpi[0])); PMPI_Isend(pmpi_inbuf, 2, pmpi_vector_ddt, peer, 0, MPI_COMM_WORLD, &(requests_pmpi[1])); } int flag; flag = 0; while (flag == 0) MPI_Test(&(requests_mpi[0]), &flag, &(statuses_mpi[0])); flag = 0; while (flag == 0) MPI_Test(&(requests_mpi[1]), &flag, &(statuses_mpi[1])); flag = 0; while (flag == 0) MPI_Test(&(requests_pmpi[0]), &flag, &(statuses_pmpi[0])); flag = 0; while (flag == 0) MPI_Test(&(requests_pmpi[1]), &flag, &(statuses_pmpi[1])); int res = compare_buffers(20*sizeof(int), &mpi_inbuf, &pmpi_inbuf, &mpi_outbuf, &pmpi_outbuf); free_buffers(&mpi_inbuf, &pmpi_inbuf, &mpi_outbuf, &pmpi_outbuf); test_result(res); MPI_Type_free(&vector_ddt); PMPI_Type_free(&pmpi_vector_ddt); MPI_Finalize(); }
/* * mpiPi_collect_basics() - all tasks send their basic info to the * collectorRank. */ void mpiPi_collect_basics () { int i = 0; double app_time = mpiPi.cumulativeTime; int cnt; mpiPi_task_info_t mti; int blockcounts[4] = { 1, 1, 1, MPIPI_HOSTNAME_LEN_MAX }; MPI_Datatype types[4] = { MPI_DOUBLE, MPI_DOUBLE, MPI_INT, MPI_CHAR }; MPI_Aint displs[4]; MPI_Datatype mti_type; MPI_Request *recv_req_arr; mpiPi_msg_debug ("Collect Basics\n"); cnt = 0; PMPI_Address (&mti.mpi_time, &displs[cnt++]); PMPI_Address (&mti.app_time, &displs[cnt++]); PMPI_Address (&mti.rank, &displs[cnt++]); PMPI_Address (&mti.hostname, &displs[cnt++]); for (i = (cnt - 1); i >= 0; i--) { displs[i] -= displs[0]; } PMPI_Type_struct (cnt, blockcounts, displs, types, &mti_type); PMPI_Type_commit (&mti_type); if (mpiPi.rank == mpiPi.collectorRank) { /* In the case where multiple reports are generated per run, only allocate memory for global_task_info once */ if (mpiPi.global_task_info == NULL) { mpiPi.global_task_info = (mpiPi_task_info_t *) calloc (mpiPi.size, sizeof (mpiPi_task_info_t)); if (mpiPi.global_task_info == NULL) mpiPi_abort ("Failed to allocate memory for global_task_info"); mpiPi_msg_debug ("MEMORY : Allocated for global_task_info : %13ld\n", mpiPi.size * sizeof (mpiPi_task_info_t)); } bzero (mpiPi.global_task_info, mpiPi.size * sizeof (mpiPi_task_info_t)); recv_req_arr = (MPI_Request *) malloc (sizeof (MPI_Request) * mpiPi.size); for (i = 0; i < mpiPi.size; i++) { mpiPi_task_info_t *p = &mpiPi.global_task_info[i]; if (i != mpiPi.collectorRank) { PMPI_Irecv (p, 1, mti_type, i, mpiPi.tag, mpiPi.comm, &(recv_req_arr[i])); } else { strcpy (p->hostname, mpiPi.hostname); p->app_time = app_time; p->rank = mpiPi.rank; recv_req_arr[i] = MPI_REQUEST_NULL; } } PMPI_Waitall (mpiPi.size, recv_req_arr, MPI_STATUSES_IGNORE); free (recv_req_arr); /* task MPI time is calculated from callsites data in mpiPi_insert_callsite_records. */ for (i = 0; i < mpiPi.size; i++) mpiPi.global_task_info[i].mpi_time = 0.0; } else { strcpy (mti.hostname, mpiPi.hostname); mti.app_time = app_time; mti.rank = mpiPi.rank; PMPI_Send (&mti, 1, mti_type, mpiPi.collectorRank, mpiPi.tag, mpiPi.comm); } PMPI_Type_free (&mti_type); return; }
int MPI_Irecv(void *buf, int count, MPI_Datatype datatype, int src, int tag, MPI_Comm comm, MPI_Request * request) { return PMPI_Irecv(buf, count, datatype, src, tag, comm, request); }