-: 0:Source:/home/MPI/testing/mpich2/mpich2/src/mpid/ch3/src/ch3u_rndv.c
-: 0:Graph:ch3u_rndv.gcno
-: 0:Data:ch3u_rndv.gcda
-: 0:Runs:3459
-: 0:Programs:899
-: 1:/* -*- Mode: C; c-basic-offset:4 ; -*- */
-: 2:/*
-: 3: * (C) 2001 by Argonne National Laboratory.
-: 4: * See COPYRIGHT in top-level directory.
-: 5: */
-: 6:
-: 7:#include "mpidimpl.h"
-: 8:
-: 9:/*
-: 10: * This file contains the implementation of the rendezvous protocol
-: 11: * for MPI point-to-point messaging.
-: 12: */
-: 13:
-: 14:#undef FUNCNAME
-: 15:#define FUNCNAME MPIDI_CH3_RndvSend
-: 16:#undef FCNAME
-: 17:#define FCNAME MPIDI_QUOTE(FUNCNAME)
-: 18:/* MPIDI_CH3_RndvSend - Send a request to perform a rendezvous send */
-: 19:int MPIDI_CH3_RndvSend( MPID_Request **sreq_p, const void * buf, int count,
-: 20: MPI_Datatype datatype, int dt_contig, MPIDI_msg_sz_t data_sz,
-: 21: MPI_Aint dt_true_lb,
-: 22: int rank,
-: 23: int tag, MPID_Comm * comm, int context_offset )
10141: 24:{
-: 25: MPIDI_CH3_Pkt_t upkt;
10141: 26: MPIDI_CH3_Pkt_rndv_req_to_send_t * const rts_pkt = &upkt.rndv_req_to_send;
-: 27: MPIDI_VC_t * vc;
-: 28: MPID_Request * rts_sreq;
10141: 29: MPID_Request *sreq =*sreq_p;
10141: 30: int mpi_errno = MPI_SUCCESS;
-: 31:
-: 32: MPIU_DBG_MSG_D(CH3_OTHER,VERBOSE,
-: 33: "sending rndv RTS, data_sz=" MPIDI_MSG_SZ_FMT, data_sz);
-: 34:
10141: 35: sreq->dev.OnDataAvail = 0;
-: 36:
10141: 37: sreq->partner_request = NULL;
-: 38:
10141: 39: MPIDI_Pkt_init(rts_pkt, MPIDI_CH3_PKT_RNDV_REQ_TO_SEND);
10141: 40: rts_pkt->match.parts.rank = comm->rank;
10141: 41: rts_pkt->match.parts.tag = tag;
10141: 42: rts_pkt->match.parts.context_id = comm->context_id + context_offset;
10141: 43: rts_pkt->sender_req_id = sreq->handle;
10141: 44: rts_pkt->data_sz = data_sz;
-: 45:
10141: 46: MPIDI_Comm_get_vc_set_active(comm, rank, &vc);
-: 47: MPIDI_VC_FAI_send_seqnum(vc, seqnum);
-: 48: MPIDI_Pkt_set_seqnum(rts_pkt, seqnum);
-: 49: MPIDI_Request_set_seqnum(sreq, seqnum);
-: 50:
-: 51: MPIU_DBG_MSGPKT(vc,tag,rts_pkt->match.parts.context_id,rank,data_sz,"Rndv");
-: 52:
-: 53: MPIU_THREAD_CS_ENTER(CH3COMM,vc);
10141: 54: mpi_errno = MPIU_CALL(MPIDI_CH3,iStartMsg(vc, rts_pkt, sizeof(*rts_pkt),
-: 55: &rts_sreq));
-: 56: MPIU_THREAD_CS_EXIT(CH3COMM,vc);
|
-: 57: /* --BEGIN ERROR HANDLING-- */
10141: 58: if (mpi_errno != MPI_SUCCESS)
-: 59: {
#####: 60: MPIU_Object_set_ref(sreq, 0);
#####: 61: MPIDI_CH3_Request_destroy(sreq);
#####: 62: *sreq_p = NULL;
#####: 63: mpi_errno = MPIR_Err_create_code(mpi_errno, MPIR_ERR_FATAL, FCNAME, __LINE__, MPI_ERR_OTHER, "**ch3|rtspkt", 0);
#####: 64: goto fn_exit;
-: 65: }
-: 66: /* --END ERROR HANDLING-- */
|
10141: 67: if (rts_sreq != NULL)
-: 68: {
4: 69: if (rts_sreq->status.MPI_ERROR != MPI_SUCCESS)
-: 70: {
|
#####: 71: MPIU_Object_set_ref(sreq, 0);
#####: 72: MPIDI_CH3_Request_destroy(sreq);
#####: 73: *sreq_p = NULL;
|
#####: 74: mpi_errno = MPIR_Err_create_code(rts_sreq->status.MPI_ERROR, MPIR_ERR_FATAL, FCNAME, __LINE__, MPI_ERR_OTHER, "**ch3|rtspkt", 0);
|
#####: 75: MPID_Request_release(rts_sreq);
-: 76: goto fn_exit;
-: 77: }
|
4: 78: MPID_Request_release(rts_sreq);
-: 79: }
-: 80:
-: 81: /* FIXME: fill temporary IOV or pack temporary buffer after send to hide
-: 82: some latency. This requires synchronization
-: 83: because the CTS packet could arrive and be processed before the above
-: 84: iStartmsg completes (depending on the progress
-: 85: engine, threads, etc.). */
-: 86:
10141: 87: fn_exit:
-: 88:
10141: 89: return mpi_errno;
-: 90:}
-: 91:
-: 92:/*
-: 93: * Here are the routines that are called by the progress engine to handle
-: 94: * the various rendezvous message requests (cancel of sends is in
-: 95: * mpid_cancel_send.c).
-: 96: */
-: 97:
-: 98:#define set_request_info(rreq_, pkt_, msg_type_) \
-: 99:{ \
-: 100: (rreq_)->status.MPI_SOURCE = (pkt_)->match.parts.rank; \
-: 101: (rreq_)->status.MPI_TAG = (pkt_)->match.parts.tag; \
-: 102: (rreq_)->status.count = (pkt_)->data_sz; \
-: 103: (rreq_)->dev.sender_req_id = (pkt_)->sender_req_id; \
-: 104: (rreq_)->dev.recv_data_sz = (pkt_)->data_sz; \
-: 105: MPIDI_Request_set_seqnum((rreq_), (pkt_)->seqnum); \
-: 106: MPIDI_Request_set_msg_type((rreq_), (msg_type_)); \
-: 107:}
-: 108:
-: 109:#undef FUNCNAME
-: 110:#define FUNCNAME MPIDI_CH3_PktHandler_RndvReqToSend
-: 111:#undef FCNAME
-: 112:#define FCNAME MPIDI_QUOTE(FUNCNAME)
-: 113:int MPIDI_CH3_PktHandler_RndvReqToSend( MPIDI_VC_t *vc, MPIDI_CH3_Pkt_t *pkt,
-: 114: MPIDI_msg_sz_t *buflen, MPID_Request **rreqp )
10141: 115:{
-: 116: MPID_Request * rreq;
-: 117: int found;
10141: 118: MPIDI_CH3_Pkt_rndv_req_to_send_t * rts_pkt = &pkt->rndv_req_to_send;
10141: 119: int mpi_errno = MPI_SUCCESS;
-: 120:
-: 121: MPIU_DBG_MSG_FMT(CH3_OTHER,VERBOSE,(MPIU_DBG_FDEST,
-: 122: "received rndv RTS pkt, sreq=0x%08x, rank=%d, tag=%d, context=%d, data_sz=" MPIDI_MSG_SZ_FMT,
-: 123: rts_pkt->sender_req_id, rts_pkt->match.parts.rank,
-: 124: rts_pkt->match.parts.tag,
-: 125: rts_pkt->match.parts.context_id, rts_pkt->data_sz));
-: 126: MPIU_DBG_MSGPKT(vc,rts_pkt->match.parts.tag,rts_pkt->match.parts.context_id,
-: 127: rts_pkt->match.parts.rank,rts_pkt->data_sz,
-: 128: "ReceivedRndv");
-: 129:
10141: 130: rreq = MPIDI_CH3U_Recvq_FDP_or_AEU(&rts_pkt->match, &found);
10141: 131: MPIU_ERR_CHKANDJUMP1(!rreq, mpi_errno,MPI_ERR_OTHER, "**nomemreq", "**nomemuereq %d", MPIDI_CH3U_Recvq_count_unexp());
-: 132:
10141: 133: set_request_info(rreq, rts_pkt, MPIDI_REQUEST_RNDV_MSG);
-: 134:
10141: 135: *buflen = sizeof(MPIDI_CH3_Pkt_t);
-: 136:
10141: 137: if (found)
-: 138: {
-: 139: MPID_Request * cts_req;
-: 140: MPIDI_CH3_Pkt_t upkt;
9445: 141: MPIDI_CH3_Pkt_rndv_clr_to_send_t * cts_pkt = &upkt.rndv_clr_to_send;
-: 142:
-: 143: MPIU_DBG_MSG(CH3_OTHER,VERBOSE,"posted request found");
-: 144:
-: 145: /* FIXME: What if the receive user buffer is not big enough to
-: 146: hold the data about to be cleared for sending? */
-: 147:
-: 148: MPIU_DBG_MSG(CH3_OTHER,VERBOSE,"sending rndv CTS packet");
9445: 149: MPIDI_Pkt_init(cts_pkt, MPIDI_CH3_PKT_RNDV_CLR_TO_SEND);
9445: 150: cts_pkt->sender_req_id = rts_pkt->sender_req_id;
9445: 151: cts_pkt->receiver_req_id = rreq->handle;
-: 152: /* Because this is a packet-handler function, it will be called from within a Critical section */
-: 153: /* FIXME: is that a ch3 or an mpid critical section? */
-: 154: /* MPIU_THREAD_CS_ENTER(CH3COMM,vc); */
9445: 155: mpi_errno = MPIU_CALL(MPIDI_CH3,iStartMsg(vc, cts_pkt,
-: 156: sizeof(*cts_pkt), &cts_req));
-: 157: /* MPIU_THREAD_CS_EXIT(CH3COMM,vc); */
9445: 158: if (mpi_errno != MPI_SUCCESS) {
|
#####: 159: MPIU_ERR_SETANDJUMP(mpi_errno,MPI_ERR_OTHER,
-: 160: "**ch3|ctspkt");
-: 161: }
|
9445: 162: if (cts_req != NULL) {
7: 163: MPID_Request_release(cts_req);
-: 164: }
-: 165: }
-: 166: else
-: 167: {
-: 168: MPIU_DBG_MSG(CH3_OTHER,VERBOSE,"unexpected request allocated");
-: 169:
-: 170: /*
-: 171: * A MPID_Probe() may be waiting for the request we just
-: 172: * inserted, so we need to tell the progress engine to exit.
-: 173: *
-: 174: * FIXME: This will cause MPID_Progress_wait() to return to the
-: 175: * MPI layer each time an unexpected RTS packet is
-: 176: * received. MPID_Probe() should atomically increment a
-: 177: * counter and MPIDI_CH3_Progress_signal_completion()
-: 178: * should only be called if that counter is greater than zero.
-: 179: */
696: 180: MPIDI_CH3_Progress_signal_completion();
-: 181: }
-: 182:
10141: 183: *rreqp = NULL;
-: 184:
|
10141: 185: fn_fail:
|
10141: 186: return mpi_errno;
-: 187:}
-: 188:
-: 189:#undef FUNCNAME
-: 190:#define FUNCNAME MPIDI_CH3_PktHandler_RndvClrToSend
-: 191:#undef FCNAME
-: 192:#define FCNAME MPIDI_QUOTE(FUNCNAME)
-: 193:int MPIDI_CH3_PktHandler_RndvClrToSend( MPIDI_VC_t *vc, MPIDI_CH3_Pkt_t *pkt,
-: 194: MPIDI_msg_sz_t *buflen, MPID_Request **rreqp )
10133: 195:{
10133: 196: MPIDI_CH3_Pkt_rndv_clr_to_send_t * cts_pkt = &pkt->rndv_clr_to_send;
-: 197: MPID_Request * sreq;
-: 198: MPID_Request * rts_sreq;
-: 199: MPIDI_CH3_Pkt_t upkt;
10133: 200: MPIDI_CH3_Pkt_rndv_send_t * rs_pkt = &upkt.rndv_send;
-: 201: int dt_contig;
-: 202: MPI_Aint dt_true_lb;
-: 203: MPIDI_msg_sz_t data_sz;
-: 204: MPID_Datatype * dt_ptr;
10133: 205: int mpi_errno = MPI_SUCCESS;
-: 206:
-: 207: MPIU_DBG_MSG(CH3_OTHER,VERBOSE,"received rndv CTS pkt");
-: 208:
10133: 209: MPID_Request_get_ptr(cts_pkt->sender_req_id, sreq);
-: 210: MPIU_DBG_PRINTF(("received cts, count=%d\n", sreq->dev.user_count));
-: 211:
10133: 212: sreq->dev.OnDataAvail = 0;
10133: 213: sreq->dev.OnFinal = 0;
-: 214:
-: 215: /* Release the RTS request if one exists.
-: 216: MPID_Request_fetch_and_clear_rts_sreq() needs to be atomic to
-: 217: prevent
-: 218: cancel send from cancelling the wrong (future) request.
-: 219: If MPID_Request_fetch_and_clear_rts_sreq() returns a NULL
-: 220: rts_sreq, then MPID_Cancel_send() is responsible for releasing
-: 221: the RTS request object. */
10133: 222: MPIDI_Request_fetch_and_clear_rts_sreq(sreq, &rts_sreq);
10133: 223: if (rts_sreq != NULL)
-: 224: {
|
#####: 225: MPID_Request_release(rts_sreq);
-: 226: }
-: 227:
|
10133: 228: *buflen = sizeof(MPIDI_CH3_Pkt_t);
-: 229:
10133: 230: MPIDI_Pkt_init(rs_pkt, MPIDI_CH3_PKT_RNDV_SEND);
10133: 231: rs_pkt->receiver_req_id = cts_pkt->receiver_req_id;
-: 232:
10133: 233: MPIDI_Datatype_get_info(sreq->dev.user_count, sreq->dev.datatype, dt_contig, data_sz, dt_ptr, dt_true_lb);
-: 234:
10133: 235: if (dt_contig)
-: 236: {
-: 237: MPID_IOV iov[MPID_IOV_LIMIT];
-: 238:
-: 239: MPIU_DBG_MSG_FMT(CH3_OTHER,VERBOSE,(MPIU_DBG_FDEST,
-: 240: "sending contiguous rndv data, data_sz=" MPIDI_MSG_SZ_FMT,
-: 241: data_sz));
-: 242:
9930: 243: iov[0].MPID_IOV_BUF = (MPID_IOV_BUF_CAST)rs_pkt;
9930: 244: iov[0].MPID_IOV_LEN = sizeof(*rs_pkt);
-: 245:
9930: 246: iov[1].MPID_IOV_BUF = (MPID_IOV_BUF_CAST)((char *)sreq->dev.user_buf + dt_true_lb);
9930: 247: iov[1].MPID_IOV_LEN = data_sz;
-: 248:
-: 249: /* MPIU_THREAD_CS_ENTER(CH3COMM,vc);*/
9930: 250: mpi_errno = MPIU_CALL(MPIDI_CH3,iSendv(vc, sreq, iov, 2));
-: 251: /* MPIU_THREAD_CS_EXIT(CH3COMM,vc); */
9930: 252: MPIU_ERR_CHKANDJUMP(mpi_errno, mpi_errno, MPI_ERR_OTHER, "**ch3|senddata");
-: 253: }
-: 254: else
-: 255: {
203: 256: sreq->dev.segment_ptr = MPID_Segment_alloc( );
203: 257: MPIU_ERR_CHKANDJUMP1((sreq->dev.segment_ptr == NULL), mpi_errno, MPI_ERR_OTHER, "**nomem", "**nomem %s", "MPID_Segment_alloc");
203: 258: MPID_Segment_init(sreq->dev.user_buf, sreq->dev.user_count,
-: 259: sreq->dev.datatype, sreq->dev.segment_ptr, 0);
203: 260: sreq->dev.segment_first = 0;
203: 261: sreq->dev.segment_size = data_sz;
-: 262:
-: 263: /*MPIU_THREAD_CS_ENTER(CH3COMM,vc);*/
203: 264: mpi_errno = vc->sendNoncontig_fn(vc, sreq, rs_pkt, sizeof(*rs_pkt));
-: 265: /*MPIU_THREAD_CS_EXIT(CH3COMM,vc);*/
203: 266: MPIU_ERR_CHKANDJUMP(mpi_errno, mpi_errno, MPI_ERR_OTHER, "**ch3|senddata");
-: 267: }
10133: 268: *rreqp = NULL;
-: 269:
|
10133: 270: fn_fail:
|
10133: 271: return mpi_errno;
-: 272:}
-: 273:
-: 274:#undef FUNCNAME
-: 275:#define FUNCNAME MPIDI_CH3_PktHandler_RndvSend
-: 276:#undef FCNAME
-: 277:#define FCNAME MPIDI_QUOTE(FUNCNAME)
-: 278:int MPIDI_CH3_PktHandler_RndvSend( MPIDI_VC_t *vc, MPIDI_CH3_Pkt_t *pkt,
-: 279: MPIDI_msg_sz_t *buflen, MPID_Request **rreqp )
10133: 280:{
10133: 281: MPIDI_CH3_Pkt_rndv_send_t * rs_pkt = &pkt->rndv_send;
10133: 282: int mpi_errno = MPI_SUCCESS;
-: 283: int complete;
-: 284: char *data_buf;
-: 285: MPIDI_msg_sz_t data_len;
-: 286: MPID_Request *req;
-: 287:
-: 288: MPIU_DBG_MSG(CH3_OTHER,VERBOSE,"received rndv send (data) pkt");
-: 289:
10133: 290: MPID_Request_get_ptr(rs_pkt->receiver_req_id, req);
-: 291:
10133: 292: data_len = ((*buflen - sizeof(MPIDI_CH3_Pkt_t) >= req->dev.recv_data_sz)
-: 293: ? req->dev.recv_data_sz : *buflen - sizeof(MPIDI_CH3_Pkt_t));
10133: 294: data_buf = (char *)pkt + sizeof(MPIDI_CH3_Pkt_t);
-: 295:
10133: 296: if (req->dev.recv_data_sz == 0) {
|
#####: 297: *buflen = sizeof(MPIDI_CH3_Pkt_t);
#####: 298: MPIDI_CH3U_Request_complete(req);
#####: 299: *rreqp = NULL;
-: 300: }
-: 301: else {
|
10133: 302: mpi_errno = MPIDI_CH3U_Receive_data_found(req, data_buf, &data_len,
-: 303: &complete);
10133: 304: if (mpi_errno != MPI_SUCCESS) {
|
#####: 305: MPIU_ERR_SETANDJUMP1(mpi_errno,MPI_ERR_OTHER, "**ch3|postrecv",
-: 306: "**ch3|postrecv %s", "MPIDI_CH3_PKT_RNDV_SEND");
-: 307: }
-: 308:
|
10133: 309: *buflen = sizeof(MPIDI_CH3_Pkt_t) + data_len;
-: 310:
10133: 311: if (complete)
-: 312: {
|
#####: 313: MPIDI_CH3U_Request_complete(req);
#####: 314: *rreqp = NULL;
-: 315: }
-: 316: else
-: 317: {
|
10133: 318: *rreqp = req;
-: 319: }
-: 320: }
-: 321:
|
10133: 322: fn_fail:
|
10133: 323: return mpi_errno;
-: 324:}
-: 325:
-: 326:/*
-: 327: * This routine processes a rendezvous message once the message is matched.
-: 328: * It is used in mpid_recv and mpid_irecv.
-: 329: */
-: 330:#undef FUNCNAME
-: 331:#define FUNCNAME MPIDI_CH3_RecvRndv
-: 332:#undef FCNAME
-: 333:#define FCNAME MPIDI_QUOTE(FUNCNAME)
-: 334:int MPIDI_CH3_RecvRndv( MPIDI_VC_t * vc, MPID_Request *rreq )
688: 335:{
688: 336: int mpi_errno = MPI_SUCCESS;
-: 337:
-: 338: /* A rendezvous request-to-send (RTS) message has arrived. We need
-: 339: to send a CTS message to the remote process. */
-: 340: MPID_Request * cts_req;
-: 341: MPIDI_CH3_Pkt_t upkt;
688: 342: MPIDI_CH3_Pkt_rndv_clr_to_send_t * cts_pkt = &upkt.rndv_clr_to_send;
-: 343:
-: 344: MPIU_DBG_MSG(CH3_OTHER,VERBOSE,
-: 345: "rndv RTS in the request, sending rndv CTS");
-: 346:
688: 347: MPIDI_Pkt_init(cts_pkt, MPIDI_CH3_PKT_RNDV_CLR_TO_SEND);
688: 348: cts_pkt->sender_req_id = rreq->dev.sender_req_id;
688: 349: cts_pkt->receiver_req_id = rreq->handle;
-: 350: MPIU_THREAD_CS_ENTER(CH3COMM,vc);
688: 351: mpi_errno = MPIU_CALL(MPIDI_CH3,iStartMsg(vc, cts_pkt,
-: 352: sizeof(*cts_pkt), &cts_req));
-: 353: MPIU_THREAD_CS_EXIT(CH3COMM,vc);
688: 354: if (mpi_errno != MPI_SUCCESS) {
|
#####: 355: MPIU_ERR_SETANDJUMP(mpi_errno,MPI_ERR_OTHER, "**ch3|ctspkt");
-: 356: }
|
688: 357: if (cts_req != NULL)
-: 358: {
-: 359: /* FIXME: Ideally we could specify that a req not be returned.
-: 360: This would avoid our having to decrement the
-: 361: reference count on a req we don't want/need. */
|
#####: 362: MPID_Request_release(cts_req);
-: 363: }
-: 364:
|
688: 365: fn_fail:
|
688: 366: return mpi_errno;
-: 367:}
-: 368:
-: 369:/*
-: 370: * Define the routines that can print out the cancel packets if
-: 371: * debugging is enabled.
-: 372: */
-: 373:#ifdef MPICH_DBG_OUTPUT
-: 374:int MPIDI_CH3_PktPrint_RndvReqToSend( FILE *fp, MPIDI_CH3_Pkt_t *pkt )
-: 375:{
-: 376: MPIU_DBG_PRINTF((" type ......... REQ_TO_SEND\n"));
-: 377: MPIU_DBG_PRINTF((" sender_reqid . 0x%08X\n", pkt->rndv_req_to_send.sender_req_id));
-: 378: MPIU_DBG_PRINTF((" context_id ... %d\n", pkt->rndv_req_to_send.match.parts.context_id));
-: 379: MPIU_DBG_PRINTF((" tag .......... %d\n", pkt->rndv_req_to_send.match.parts.tag));
-: 380: MPIU_DBG_PRINTF((" rank ......... %d\n", pkt->rndv_req_to_send.match.parts.rank));
-: 381: MPIU_DBG_PRINTF((" data_sz ...... %d\n", pkt->rndv_req_to_send.data_sz));
-: 382:#ifdef MPID_USE_SEQUENCE_NUMBERS
-: 383: MPIU_DBG_PRINTF((" seqnum ....... %d\n", pkt->rndv_req_to_send.seqnum));
-: 384:#endif
-: 385: return MPI_SUCCESS;
-: 386:}
-: 387:int MPIDI_CH3_PktPrint_RndvClrToSend( FILE *fp, MPIDI_CH3_Pkt_t *pkt )
-: 388:{
-: 389: MPIU_DBG_PRINTF((" type ......... CLR_TO_SEND\n"));
-: 390: MPIU_DBG_PRINTF((" sender_reqid . 0x%08X\n", pkt->rndv_clr_to_send.sender_req_id));
-: 391: MPIU_DBG_PRINTF((" recvr_reqid .. 0x%08X\n", pkt->rndv_clr_to_send.receiver_req_id));
-: 392: return MPI_SUCCESS;
-: 393:}
-: 394:int MPIDI_CH3_PktPrint_RndvSend( FILE *fp, MPIDI_CH3_Pkt_t *pkt )
-: 395:{
-: 396: MPIU_DBG_PRINTF((" type ......... RNDV_SEND\n"));
-: 397: MPIU_DBG_PRINTF((" recvr_reqid .. 0x%08X\n", pkt->rndv_send.receiver_req_id));
-: 398: return MPI_SUCCESS;
-: 399:}
-: 400:#endif
-: 401:
|