ibu_wait.vapi.c

mpi并行计算的c++代码 可用vc或gcc编译通过 可以用来搭建并行计算试验环境

	    /*if (ibu->state & IBU_RDMA_WRITING)*/
	    {
		MPI_Request rreq_cached;
		int complete = 0;
		ibu->state &= ~IBU_RDMA_WRITING;
		sreq = (MPID_Request*)mem_ptr;
		MPIU_DBG_PRINTF(("sreq after rdma write: sreq=0x%x, rreq=0x%x\n", sreq->handle, sreq->dev.rdma_request));
		rreq_cached = sreq->dev.rdma_request;
		if (sreq->ch.reload_state & MPIDI_CH3I_RELOAD_SENDER)
		{
		    MPIU_DBG_PRINTF(("unregistering and reloading the sender's iov.\n"));
		    /* unpin the sender's iov */
		    sreq->ch.rndv_status = IBU_RNDV_SUCCESS;
		    for (i=0; i<sreq->dev.iov_count; i++)
		    {
			ibu_reg_status = ibu_deregister_memory(
			    sreq->dev.iov[i].MPID_IOV_BUF, 
			    sreq->dev.iov[i].MPID_IOV_LEN, 
			    &sreq->ch.local_iov_mem[i]);
			/* --BEGIN ERROR HANDLING-- */
			if (ibu_reg_status != IBU_SUCCESS) 
			{						
			    mpi_errno = MPIR_Err_create_code(mpi_errno, MPIR_ERR_FATAL, FCNAME, __LINE__, MPI_ERR_OTHER, "**fail", "**fail %s", "unable to deregister");
			    MPIU_DBG_PRINTFX(("exiting ibu_wait deregister failed a\n"));
			    MPIDI_FUNC_EXIT(MPID_STATE_IBU_WAIT);
			    return mpi_errno;
			}
			/* --END ERROR HANDLING-- */
		    }				
		    /* update the sender's request */
		    mpi_errno = MPIDI_CH3U_Handle_send_req(ibu->vc_ptr, sreq, &complete);
		    if (mpi_errno != MPI_SUCCESS)
		    {
			mpi_errno = MPIR_Err_create_code(mpi_errno, MPIR_ERR_FATAL, FCNAME, __LINE__, MPI_ERR_OTHER, "**fail", "**fail %s", "unable to update request after rdma write");
			MPIU_DBG_PRINTFX(("exiting ibu_wait a\n"));
			MPIDI_FUNC_EXIT(MPID_STATE_IBU_WAIT);
			return mpi_errno;
		    }
		}
		if ((sreq->ch.reload_state & MPIDI_CH3I_RELOAD_RECEIVER) || complete)
		{
		    MPIDI_CH3_Pkt_t pkt;
		    MPIDI_CH3_Pkt_rdma_reload_t * reload_pkt = &pkt.reload;
		    MPID_Request *reload_sreq = NULL;

		    MPIU_DBG_PRINTF(("sending a reload/done packet (sreq=0x%x, rreq=0x%x).\n", sreq->handle, rreq_cached));
		    /* send the reload/done packet to the receiver */
		    MPIDI_Pkt_init(reload_pkt, MPIDI_CH3_PKT_RELOAD);
		    reload_pkt->rreq = rreq_cached/*sreq->dev.rdma_request*/;
		    reload_pkt->sreq = sreq->handle;
		    reload_pkt->send_recv = MPIDI_CH3_PKT_RELOAD_RECV;
		    mpi_errno = MPIDI_CH3_iStartMsg(ibu->vc_ptr, reload_pkt, sizeof(*reload_pkt), &reload_sreq);
		    /* --BEGIN ERROR HANDLING-- */
		    if (mpi_errno != MPI_SUCCESS)
		    {
			mpi_errno = MPIR_Err_create_code(mpi_errno, MPIR_ERR_FATAL, FCNAME, __LINE__, MPI_ERR_OTHER, "**fail", 0);
			MPIU_DBG_PRINTFX(("exiting ibu_wait b\n"));
			MPIDI_FUNC_EXIT(MPID_STATE_IBU_WAIT);
			return mpi_errno;
		    }
		    /* --END ERROR HANDLING-- */
		    if (reload_sreq != NULL)
		    {
			/* The sender doesn't need to know when the packet has been sent.  So release the request immediately */
			MPID_Request_release(reload_sreq);
		    }
		}
		if (sreq->ch.reload_state & MPIDI_CH3I_RELOAD_SENDER && !complete)
		{
		    /* pin the sender's iov */
		    MPIU_DBG_PRINTF(("registering the sender's iov.\n"));
		    sreq->ch.rndv_status = IBU_RNDV_NO_DEREG;
		    for (i=0; i<sreq->dev.iov_count; i++)
		    {
			sreq->ch.rndv_status = IBU_RNDV_SUCCESS;
			ibu_reg_status = ibu_register_memory(
			    sreq->dev.iov[i].MPID_IOV_BUF, 
			    sreq->dev.iov[i].MPID_IOV_LEN, 
			    &sreq->ch.local_iov_mem[i]);
			if (ibu_reg_status != IBU_SUCCESS) break;
		    }
		    if (ibu_reg_status != IBU_SUCCESS)
		    {
			sreq->ch.rndv_status = IBU_RNDV_RTS_FAIL;
			/* Deregister all register buffers we are not going to use */ 
			MPIU_DBG_PRINTF(("ibu_register_memory failed. deregistering the sender's iov.\n"));
			if (i > 0) 
			{
			    for (i-=1; i==0; i--) /* take last i's value one down, since last did not succeed*/
			    {
				ibu_reg_status = ibu_deregister_memory(
				    sreq->dev.iov[i].MPID_IOV_BUF, 
				    sreq->dev.iov[i].MPID_IOV_LEN, 
				    &sreq->ch.local_iov_mem[i]);
				/* --BEGIN ERROR HANDLING-- */
				if (ibu_reg_status != IBU_SUCCESS)
				{								
				    mpi_errno = MPIR_Err_create_code(mpi_errno, MPIR_ERR_FATAL, FCNAME, __LINE__, MPI_ERR_OTHER, "**fail", "**fail %s", "unable to deregister");
				    MPIU_DBG_PRINTFX(("exiting ibu_wait deregister failed b\n"));
				    MPIDI_FUNC_EXIT(MPID_STATE_IBU_WAIT);
				    return mpi_errno;
				}
				/* --END ERROR HANDLING-- */
			    }
			}					
		    }
		}
		if ((!complete) && !(sreq->ch.reload_state & MPIDI_CH3I_RELOAD_RECEIVER))
		{
		    sreq->ch.reload_state = 0;				
		    if (sreq->ch.rndv_status == IBU_RNDV_SUCCESS) 
		    {
			/* do some more rdma writes */
			mpi_errno = MPIDI_CH3I_rdma_writev(ibu->vc_ptr, sreq);
			/* --BEGIN ERROR HANDLING-- */
			if (mpi_errno != MPI_SUCCESS)
			{
			    mpi_errno = MPIR_Err_create_code(mpi_errno, MPIR_ERR_FATAL, FCNAME, __LINE__, MPI_ERR_OTHER, "**fail", 0);
			    MPIU_DBG_PRINTFX(("exiting ibu_wait c\n"));
			    MPIDI_FUNC_EXIT(MPID_STATE_IBU_WAIT);
			    return mpi_errno;
			}
			/* --END ERROR HANDLING-- */
		    }
		    else 
		    {
			/* switch to EAGER sending with special packet type (set in switch routine)*/
			MPIDI_CH3_Pkt_t pkt;
			MPIDI_CH3_Pkt_rndv_eager_send_t * rndv_eager_pkt = &pkt.rndv_eager_send;
			MPIU_DBG_PRINTF(("sending eager packet instead of rndv failed sender reloading\n"));
			/* send new eager packet to the receiver */
#if defined(MPID_USE_SEQUENCE_NUMBERS)
			rndv_eager_pkt->seqnum			= ibu->vc_ptr->seqnum_send;
#endif    
			rndv_eager_pkt->match.rank		= sreq->comm->rank;
			rndv_eager_pkt->match.tag		= sreq->dev.match.tag;
			rndv_eager_pkt->match.context_id	= sreq->dev.match.context_id;
			pkt.rndv_eager_send.sender_req_id	= sreq->handle;
			pkt.rndv_eager_send.receiver_req_id	= rreq_cached;

			pkt.rndv_eager_send.type = MPIDI_CH3_PKT_RNDV_EAGER_SEND;
			mpi_errno = MPIDI_CH3I_Switch_rndv_to_eager(ibu->vc_ptr, sreq, &pkt);
			/* --BEGIN ERROR HANDLING-- */
			if (mpi_errno != MPI_SUCCESS)
			{
			    mpi_errno = MPIR_Err_create_code(mpi_errno, MPIR_ERR_FATAL, FCNAME, __LINE__, MPI_ERR_OTHER, "**fail", 0);
			    MPIU_DBG_PRINTFX(("exiting ibu_wait k\n"));
			    MPIDI_FUNC_EXIT(MPID_STATE_IBU_WAIT);
			    return mpi_errno;
			}
			/* --END ERROR HANDLING-- */
		    }
		}
		else
		{
		    sreq->ch.reload_state = 0;
		    /* return from the wait */
		    *num_bytes_ptr = 0;
		    *vc_pptr = ibu->vc_ptr;
		    *op_ptr = IBU_OP_WAKEUP;
		    MPIU_DBG_PRINTFX(("exiting ibu_wait d\n"));
		    MPIDI_FUNC_EXIT(MPID_STATE_IBU_WAIT);
		    return MPI_SUCCESS;
		}
	    }
	    break;
	case VAPI_CQE_SQ_RDMA_READ:
	    if (completion_data.status != VAPI_SUCCESS)
	    {
		MPIU_Internal_error_printf("%s: send completion status = %s\n",
		    FCNAME, VAPI_wc_status_sym(completion_data.status));
		mpi_errno = MPIR_Err_create_code(MPI_SUCCESS, MPIR_ERR_FATAL, FCNAME, __LINE__, MPI_ERR_OTHER, "**fail", "**fail %s", VAPI_wc_status_sym(completion_data.status));
		PrintWC(&completion_data);
		MPIU_DBG_PRINTFX(("exiting ibu_wait 4\n"));
		MPIDI_FUNC_EXIT(MPID_STATE_IBU_WAIT);
		return mpi_errno;
	    }
	    /*if (ibu->state & IBU_RDMA_READING)*/
	    {
		MPI_Request sreq_cached;
		int complete = 0;
		ibu->state &= ~IBU_RDMA_READING;
		rreq = (MPID_Request*)mem_ptr;
		MPIU_DBG_PRINTF(("rreq after rdma read: rreq=0x%x, sreq=0x%x\n", rreq->handle, rreq->dev.rdma_request));
		sreq_cached = rreq->dev.rdma_request;
		if (rreq->ch.reload_state & MPIDI_CH3I_RELOAD_RECEIVER)
		{
		    MPIU_DBG_PRINTF(("unregistering and reloading the receiver's iov.\n"));
		    /* unpin the receiver's iov */
		    rreq->ch.rndv_status = IBU_RNDV_SUCCESS;
		    for (i=0; i<rreq->dev.iov_count; i++)
		    {
			ibu_reg_status = ibu_deregister_memory(
			    rreq->dev.iov[i].MPID_IOV_BUF,
			    rreq->dev.iov[i].MPID_IOV_LEN,
			    &rreq->ch.local_iov_mem[i]);
			/* --BEGIN ERROR HANDLING-- */
			if (ibu_reg_status != IBU_SUCCESS) 
			{
			    mpi_errno = MPIR_Err_create_code(mpi_errno, MPIR_ERR_FATAL, FCNAME, __LINE__, MPI_ERR_OTHER, "**fail", "**fail %s", "unable to deregister");
			    MPIU_DBG_PRINTFX(("exiting ibu_wait deregister failed c\n"));
			    MPIDI_FUNC_EXIT(MPID_STATE_IBU_WAIT);
			    return mpi_errno;
			}
			/* --END ERROR HANDLING-- */

		    }
		    /* update the receiver's request */
		    mpi_errno = MPIDI_CH3U_Handle_recv_req(ibu->vc_ptr, rreq, &complete);
		    if (mpi_errno != MPI_SUCCESS)
		    {
			mpi_errno = MPIR_Err_create_code(mpi_errno, MPIR_ERR_FATAL, FCNAME, __LINE__, MPI_ERR_OTHER, "**fail", "**fail %s", "unable to update request after rdma read");
			MPIU_DBG_PRINTFX(("exiting ibu_wait e\n"));
			MPIDI_FUNC_EXIT(MPID_STATE_IBU_WAIT);
			return mpi_errno;
		    }
		}
		if ((rreq->ch.reload_state & MPIDI_CH3I_RELOAD_SENDER) || complete)
		{
		    MPIDI_CH3_Pkt_t pkt;
		    MPIDI_CH3_Pkt_rdma_reload_t * reload_pkt = &pkt.reload;
		    MPID_Request *reload_rreq = NULL;

		    MPIU_DBG_PRINTF(("sending a reload/done packet (sreq=0x%x, rreq=0x%x).\n", rreq->handle, sreq_cached));
		    /* send the reload/done packet to the sender */
		    MPIDI_Pkt_init(reload_pkt, MPIDI_CH3_PKT_RELOAD);
		    reload_pkt->sreq = sreq_cached/*rreq->dev.rdma_request*/;
		    reload_pkt->rreq = rreq->handle;				
		    reload_pkt->send_recv = MPIDI_CH3_PKT_RELOAD_SEND;
		    mpi_errno = MPIDI_CH3_iStartMsg(ibu->vc_ptr, reload_pkt, sizeof(*reload_pkt), &reload_rreq);
		    /* --BEGIN ERROR HANDLING-- */
		    if (mpi_errno != MPI_SUCCESS)
		    {
			mpi_errno = MPIR_Err_create_code(mpi_errno, MPIR_ERR_FATAL, FCNAME, __LINE__, MPI_ERR_OTHER, "**fail", 0);
			MPIU_DBG_PRINTFX(("exiting ibu_wait f\n"));
			MPIDI_FUNC_EXIT(MPID_STATE_IBU_WAIT);
			return mpi_errno;
		    }
		    /* --END ERROR HANDLING-- */
		    if (reload_rreq != NULL)
		    {
			/* The sender doesn't need to know when the packet has been sent.
			So release the request immediately */
			MPID_Request_release(reload_rreq);
		    }
		}
		if (rreq->ch.reload_state & MPIDI_CH3I_RELOAD_RECEIVER && !complete)
		{
		    /* pin the receiver's iov */
		    MPIU_DBG_PRINTF(("registering the receiver's iov.\n"));
		    rreq->ch.rndv_status = IBU_RNDV_NO_DEREG;
		    for (i=0; i<rreq->dev.iov_count; i++)
		    {
			rreq->ch.rndv_status = IBU_RNDV_SUCCESS;
			ibu_reg_status = ibu_register_memory(
			    rreq->dev.iov[i].MPID_IOV_BUF,
			    rreq->dev.iov[i].MPID_IOV_LEN,
			    &rreq->ch.local_iov_mem[i]);
			if (ibu_reg_status != IBU_SUCCESS) break;
		    }
		    if (ibu_reg_status != IBU_SUCCESS)
		    {
			rreq->ch.rndv_status = IBU_RNDV_CTS_IOV_FAIL;				
			/* Deregister all register buffers we are not going to use */ 
			MPIU_DBG_PRINTF(("ibu_register_memory failed. deregistering the sender's iov.\n"));
			if (i > 0) 
			{
			    for (i-=1; i==0; i--) /* take last i's value one down, since last did not succeed*/
			    {
				ibu_reg_status = ibu_deregister_memory(
				    rreq->dev.iov[i].MPID_IOV_BUF, 
				    rreq->dev.iov[i].MPID_IOV_LEN, 
				    &rreq->ch.local_iov_mem[i]);
				/* --BEGIN ERROR HANDLING-- */
				if (ibu_reg_status != IBU_SUCCESS)
				{
				    mpi_errno = MPIR_Err_create_code(mpi_errno, MPIR_ERR_FATAL, FCNAME, __LINE__, MPI_ERR_OTHER, "**fail", "**fail %s", "unable to deregister");
				    MPIU_DBG_PRINTFX(("exiting ibu_wait deregister failed d\n"));
				    MPIDI_FUNC_EXIT(MPID_STATE_IBU_WAIT);
				    return mpi_errno;
				}
				/* --END ERROR HANDLING-- */
			    }
			}
		    }
		}
		if ((!complete) && !(rreq->ch.reload_state & MPIDI_CH3I_RELOAD_SENDER))
		{
		    rreq->ch.reload_state = 0;
		    if (rreq->ch.rndv_status == IBU_RNDV_SUCCESS) 
		    {				
			/* do some more rdma reads */
			mpi_errno = MPIDI_CH3I_rdma_readv(ibu->vc_ptr, rreq);
			/* --BEGIN ERROR HANDLING-- */
			if (mpi_errno != MPI_SUCCESS)
			{
			    mpi_errno = MPIR_Err_create_code(mpi_errno, MPIR_ERR_FATAL, FCNAME, __LINE__, MPI_ERR_OTHER, "**fail", 0);
			    MPIU_DBG_PRINTFX(("exiting ibu_wait g\n"));
			    MPIDI_FUNC_EXIT(MPID_STATE_IBU_WAIT);
			    return mpi_errno;
			}
			/* --END ERROR HANDLING-- */
		    }
		    else 
		    {
			/* Send a CTS_IOV_REG_ERROR packet. */
			rreq->dev.sender_req_id = sreq_cached;
			mpi_errno = ibui_post_rndv_cts_iov_reg_err(ibu, rreq);
			/* --BEGIN ERROR HANDLING-- */
			if (mpi_errno != MPI_SUCCESS)
			{
			    mpi_errno = MPIR_Err_create_code(mpi_errno, MPIR_ERR_FATAL, FCNAME, __LINE__, MPI_ERR_OTHER, "**fail", 0);
			    MPIU_DBG_PRINTFX(("exiting ibu_wait l\n"));
			    MPIDI_FUNC_EXIT(MPID_STATE_IBU_WAIT);
			    return mpi_errno;
			}
			/* --END ERROR HANDLING-- */
		    }
		}
		else
		{
		    rreq->ch.reload_state = 0;
		    /* return from the wait */