gm_module_send.c

fortran并行计算包

        {
            MPID_Request *sreq;
            MPIDI_VC_t *vc;
            
            if (MPID_nem_module_gm_num_send_tokens == 0)
                goto fn_exit;

            SEND_Q_DEQUEUE(&sreq);
            active_send = sreq;            
            vc = sreq->ch.vc;

	    if (active_send->ch.noncontig)
	    {
		send_noncontig_pkt(VC_FIELD(vc, gm_node_id), VC_FIELD(vc, gm_port_id), VC_FIELD(vc, source_id), &sreq->dev.pending_pkt,
				   sreq->ch.header_sz, sreq->dev.segment_ptr, &sreq->dev.segment_first, sreq->dev.segment_size);
	    }
	    else
	    {
		
		dataptr = sreq->dev.iov[0].MPID_IOV_BUF;
		datalen = sreq->dev.iov[0].MPID_IOV_LEN;
            
		send_header_pkt(VC_FIELD(vc, gm_node_id), VC_FIELD(vc, gm_port_id), VC_FIELD(vc, source_id), &sreq->dev.pending_pkt,
				sreq->ch.header_sz, &dataptr, &datalen);
            
		sreq->dev.iov[0].MPID_IOV_BUF = dataptr;
		sreq->dev.iov[0].MPID_IOV_LEN = datalen;
	    }
	}
    }    
    
 fn_exit:
    return mpi_errno;
 fn_fail:
    goto fn_exit;
}

#undef FUNCNAME
#define FUNCNAME MPID_nem_gm_iStartContigMsg
#undef FCNAME
#define FCNAME MPIDI_QUOTE(FUNCNAME)
int MPID_nem_gm_iStartContigMsg(MPIDI_VC_t *vc, void *hdr, MPIDI_msg_sz_t hdr_sz, void *data, MPIDI_msg_sz_t data_sz,
                                MPID_Request **sreq_ptr)
{
    int mpi_errno = MPI_SUCCESS;
    MPIDI_msg_sz_t dataleft = data_sz;
    char *dataptr = (char *)data;
    MPID_Request * sreq = NULL;
    MPIDI_STATE_DECL(MPID_STATE_MPID_NEM_GM_ISTARTCONTIGMSG);

    MPIDI_FUNC_ENTER(MPID_STATE_MPID_NEM_GM_ISTARTCONTIGMSG);

    MPIU_Assert(hdr_sz <= sizeof(MPIDI_CH3_Pkt_t));
    
    MPIDI_DBG_Print_packet((MPIDI_CH3_Pkt_t *)hdr);
    if (SEND_Q_EMPTY() && MPID_nem_module_gm_num_send_tokens)
        /* MT */
    {
        int node_id = VC_FIELD(vc, gm_node_id);
        int port_id = VC_FIELD(vc, gm_port_id);
        int source_id = VC_FIELD(vc, source_id);

        MPIU_DBG_MSG (CH3_CHANNEL, VERBOSE, "gm_iStartContigMsg");

        /* send first packet with header */
        send_header_pkt(node_id, port_id, source_id, hdr, hdr_sz, &dataptr, &dataleft);

        /* send additional packets of data */
        while (dataleft && MPID_nem_module_gm_num_send_tokens)
        {
            send_pkt(node_id, port_id, source_id, &dataptr, &dataleft);
        }

        if (dataleft == 0)
        {
            /* sent whole message */
            *sreq_ptr = NULL;
            goto fn_exit;
        }
    }

    /* create and enqueue request */
    MPIU_DBG_MSG (CH3_CHANNEL, VERBOSE, "enqueuing");

    /* create a request */
    sreq = MPID_Request_create();
    MPIU_Assert (sreq != NULL);
    MPIU_Object_set_ref (sreq, 2);
    sreq->kind = MPID_REQUEST_SEND;

    sreq->dev.OnDataAvail = 0;
    sreq->dev.pending_pkt = *(MPIDI_CH3_PktGeneric_t *) hdr;
    sreq->ch.noncontig = FALSE;
    sreq->ch.header_sz = hdr_sz;
    sreq->dev.iov[0].MPID_IOV_BUF = dataptr;
    sreq->dev.iov[0].MPID_IOV_LEN = dataleft;
    sreq->ch.vc = vc;

    /* if we sent anything, then the queue must have been empty */
    MPIU_Assert(dataleft == data_sz || SEND_Q_EMPTY());

    /* if we started sending this message, make it the active send */
    if (dataleft != data_sz)
        active_send = sreq;
    else
        SEND_Q_ENQUEUE(sreq);
    
    *sreq_ptr = sreq;
    
 fn_exit:
    MPIDI_FUNC_EXIT(MPID_STATE_MPID_NEM_GM_ISTARTCONTIGMSG);
    return mpi_errno;
 fn_fail:
    goto fn_exit;
}

#undef FUNCNAME
#define FUNCNAME MPID_nem_gm_iSendContig
#undef FCNAME
#define FCNAME MPIDI_QUOTE(FUNCNAME)
int MPID_nem_gm_iSendContig(MPIDI_VC_t *vc, MPID_Request *sreq, void *hdr, MPIDI_msg_sz_t hdr_sz,
                            void *data, MPIDI_msg_sz_t data_sz)
{
    int mpi_errno = MPI_SUCCESS;
    MPIDI_msg_sz_t dataleft = data_sz;
    char *dataptr = (char *)data;
    MPIDI_STATE_DECL(MPID_STATE_MPID_NEM_GM_ISENDCONTIGMSG);

    MPIDI_FUNC_ENTER(MPID_STATE_MPID_NEM_GM_ISENDCONTIGMSG);

    if (SEND_Q_EMPTY() && MPID_nem_module_gm_num_send_tokens)
        /* MT */
    {
        sendbuf_t *sb;
        int node_id = VC_FIELD(vc, gm_node_id);
        int port_id = VC_FIELD(vc, gm_port_id);
        int source_id = VC_FIELD(vc, source_id);

        MPIU_DBG_MSG (CH3_CHANNEL, VERBOSE, "gm_iSendContig");

        /* send first packet with header */
        send_header_pkt(node_id, port_id, source_id, hdr, hdr_sz, &dataptr, &dataleft);

        /* send additional packets of data */
        while (dataleft && MPID_nem_module_gm_num_send_tokens)
        {
            send_pkt(node_id, port_id, source_id, &dataptr, &dataleft);
        }

        if (dataleft == 0)
        {
            /* sent whole message */
            int (*reqFn)(MPIDI_VC_t *, MPID_Request *, int *);
            
            reqFn = sreq->dev.OnDataAvail;
            if (!reqFn)
            {
                MPIU_Assert(MPIDI_Request_get_type(sreq) != MPIDI_REQUEST_TYPE_GET_RESP);
                MPIDI_CH3U_Request_complete(sreq);
                MPIU_DBG_MSG(CH3_CHANNEL, VERBOSE, ".... complete");
                goto fn_exit;
            }
            else
            {
                int complete = 0;
                
                mpi_errno = reqFn(vc, sreq, &complete);
                if (mpi_errno) MPIU_ERR_POP(mpi_errno);

                if (complete)
                {
                    MPIU_DBG_MSG(CH3_CHANNEL, VERBOSE, ".... complete");
                    goto fn_exit;
                }

                MPIU_Assert(0); /* FIXME:  I don't think we should get here with contig messages */
                
                sreq->ch.vc = vc;
                active_send = sreq;
                goto fn_exit;
            }
        }
    }

    /* enqueue request */
    MPIU_DBG_MSG (CH3_CHANNEL, VERBOSE, "enqueuing");

    sreq->dev.pending_pkt = *(MPIDI_CH3_PktGeneric_t *) hdr;
    sreq->ch.noncontig = FALSE;
    sreq->ch.header_sz = hdr_sz;
    sreq->dev.iov[0].MPID_IOV_BUF = dataptr;
    sreq->dev.iov[0].MPID_IOV_LEN = dataleft;
    sreq->ch.vc = vc;

    /* if we sent anything, then the queue must have been empty */
    MPIU_Assert(dataleft == data_sz || SEND_Q_EMPTY());

    /* if we started sending this message, make it the active send */
    if (dataleft != data_sz)
        active_send = sreq;
    else
        SEND_Q_ENQUEUE(sreq);
  
 fn_exit:
    MPIDI_FUNC_EXIT(MPID_STATE_MPID_NEM_GM_ISENDCONTIGMSG);
    return mpi_errno;
 fn_fail:
    goto fn_exit;
}


#undef FUNCNAME
#define FUNCNAME MPID_nem_gm_SendNoncontig
#undef FCNAME
#define FCNAME MPIDI_QUOTE(FUNCNAME)
int MPID_nem_gm_SendNoncontig(MPIDI_VC_t *vc, MPID_Request *sreq, void *header, MPIDI_msg_sz_t hdr_sz)
{
    int mpi_errno = MPI_SUCCESS;
    MPIDI_STATE_DECL(MPID_STATE_MPID_NEM_GM_SENDNONCONTIG);

    MPIDI_FUNC_ENTER(MPID_STATE_MPID_NEM_GM_SENDNONCONTIG);

    if (SEND_Q_EMPTY() && MPID_nem_module_gm_num_send_tokens)
        /* MT */
    {
        sendbuf_t *sb;
        int node_id = VC_FIELD(vc, gm_node_id);
        int port_id = VC_FIELD(vc, gm_port_id);
        int source_id = VC_FIELD(vc, source_id);

        MPIU_DBG_MSG (CH3_CHANNEL, VERBOSE, "gm_SendNoncontig");

        /* send first packet with header */
	send_noncontig_pkt(node_id, port_id, source_id, header, hdr_sz,
			   sreq->dev.segment_ptr, &sreq->dev.segment_first, sreq->dev.segment_size);

        /* send additional packets of data */
        while (sreq->dev.segment_first != sreq->dev.segment_size && MPID_nem_module_gm_num_send_tokens)
        {
            send_noncontig_pkt(node_id, port_id, source_id, NULL, 0, sreq->dev.segment_ptr,
			       &sreq->dev.segment_first, sreq->dev.segment_size);
        }

        if (sreq->dev.segment_first == sreq->dev.segment_size)
        {
            /* sent whole message */
            int (*reqFn)(MPIDI_VC_t *, MPID_Request *, int *);
            
            reqFn = sreq->dev.OnDataAvail;
            if (!reqFn)
            {
                MPIU_Assert(MPIDI_Request_get_type(sreq) != MPIDI_REQUEST_TYPE_GET_RESP);
                MPIDI_CH3U_Request_complete(sreq);
                MPIU_DBG_MSG(CH3_CHANNEL, VERBOSE, ".... complete");
                goto fn_exit;
            }
            else
            {
                int complete = 0;
                
                mpi_errno = reqFn(vc, sreq, &complete);
                if (mpi_errno) MPIU_ERR_POP(mpi_errno);

                if (complete)
                {
                    MPIU_DBG_MSG(CH3_CHANNEL, VERBOSE, ".... complete");
                    goto fn_exit;
                }

                sreq->ch.vc = vc;
                active_send = sreq;
                goto fn_exit;
            }
        }
    }

    /* enqueue request */
    MPIU_DBG_MSG (CH3_CHANNEL, VERBOSE, "enqueuing");

    sreq->dev.pending_pkt = *(MPIDI_CH3_PktGeneric_t *)header;
    sreq->ch.noncontig = TRUE;
    sreq->ch.header_sz = hdr_sz;
    sreq->ch.vc = vc;

    /* if we sent anything, then the queue must have been empty */
    MPIU_Assert(sreq->dev.segment_first == 0 || SEND_Q_EMPTY());

    /* if we started sending this message, make it the active send */
    if (sreq->dev.segment_first != 0)
        active_send = sreq;
    else
        SEND_Q_ENQUEUE(sreq);
  
 fn_exit:
    MPIDI_FUNC_EXIT(MPID_STATE_MPID_NEM_GM_SENDNONCONTIG);
    return mpi_errno;
 fn_fail:
    goto fn_exit;
}