ports/openmpi
ports/openmpi
1
1
Форкнуть 0
Код Релизы Активность

-- Done with get support

Просмотр исходного кода 
-- To setup a shared completion queue, for now, separate from receive queue

This commit was SVN r2253.
Этот коммит содержится в:
Weikuan Yu 2004-08-21 14:07:41 +00:00
родитель 043a8dc3b4
Коммит 0402f520bc
2 изменённых файлов: 95 добавлений и 174 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

249
src/mca/ptl/elan/src/ptl_elan_priv.c
Просмотреть файл

@ -110,7 +110,9 @@ mca_ptl_elan_last_frag (struct mca_ptl_elan_module_t *ptl,
request, request->req_base.req_addr,
hdr->hdr_frag.hdr_frag_length);
ptl->super.ptl_recv_progress (ptl, request,
ptl->super.ptl_recv_progress (
(mca_ptl_base_module_t *) ptl,
request,
hdr->hdr_frag.hdr_frag_length,
hdr->hdr_frag.hdr_frag_length);
@ -292,19 +294,13 @@ mca_ptl_elan_init_putget_desc (struct mca_ptl_elan_send_frag_t *frag,
int size_out;
int size_in;
int rc = OMPI_SUCCESS;
ELAN4_CTX *ctx;
struct ompi_ptl_elan_putget_desc_t * desc;
mca_ptl_base_header_t *hdr;
START_FUNC((PTL_ELAN_DEBUG_PUT | PTL_ELAN_DEBUG_GET));
LOG_PRINT((PTL_ELAN_DEBUG_PUT|PTL_ELAN_DEBUG_GET),
" frag %p ptl %p ptl_peer %p req %p "
"offset %d size %d flags %d \n",
frag, ptl, ptl_peer, pml_req, offset, *size, flags);
hdr = &frag->frag_base.frag_header;
desc = (ompi_ptl_elan_putget_desc_t *)frag->desc;
destvp = ptl_peer->peer_vp;
@ -320,11 +316,9 @@ mca_ptl_elan_init_putget_desc (struct mca_ptl_elan_send_frag_t *frag,
hdr->hdr_frag.hdr_src_ptr.pval = frag; /* No need to hook a frag */
hdr->hdr_frag.hdr_dst_ptr = pml_req->req_peer_match;
hdr->hdr_frag.hdr_frag_length = size_in;
desc->src_elan_addr = elan4_main2elan (ctx, pml_req->req_base.req_addr);
desc->dst_elan_addr = (E4_Addr)pml_req->req_peer_addr.lval;
desc->desc_buff = hdr;
LOG_PRINT(PTL_ELAN_DEBUG_PUT, " remote req %p addr %x, length %d\n",
pml_req->req_peer_match.pval,
pml_req->req_peer_addr.lval,
@ -461,87 +455,28 @@ mca_ptl_elan_init_get_desc (struct mca_ptl_elan_send_frag_t *frag,
int destvp;
int size_out;
int size_in;
int rc = OMPI_SUCCESS;
ELAN4_CTX *ctx;
struct ompi_ptl_elan_putget_desc_t * desc;
mca_ptl_base_header_t *hdr;
START_FUNC(PTL_ELAN_DEBUG_GET);
LOG_PRINT((PTL_ELAN_DEBUG_PUT|PTL_ELAN_DEBUG_GET),
"frag %p ptl %p ptl_peer %p req %p "
"offset %d size %d flags %d \n",
frag, ptl, ptl_peer, pml_req, offset, *size, flags);
ctx = ptl->ptl_elan_ctx;
hdr = &frag->frag_base.frag_header;
desc = (ompi_ptl_elan_putget_desc_t *)frag->desc;
destvp = ptl_peer->peer_vp;
size_in = *size;
hdr->hdr_common.hdr_type = MCA_PTL_HDR_TYPE_FIN;
hdr->hdr_common.hdr_flags = flags;
hdr->hdr_common.hdr_size = sizeof(mca_ptl_base_frag_header_t);
hdr->hdr_frag.hdr_frag_offset = offset;
hdr->hdr_frag.hdr_frag_seq = 0;
hdr->hdr_frag.hdr_src_ptr.lval = 0;
hdr->hdr_frag.hdr_src_ptr.pval = frag; /* No need to hook a frag */
hdr->hdr_frag.hdr_dst_ptr = pml_req->req_peer_match;
hdr->hdr_frag.hdr_frag_length = size_in;
desc->src_elan_addr = elan4_main2elan (ctx, pml_req->req_base.req_addr);
desc->dst_elan_addr = (E4_Addr)pml_req->req_peer_addr.lval;
desc->src_elan_addr = elan4_main2elan(ctx, pml_req->req_base.req_addr);
desc->dst_elan_addr = 0; // (E4_Addr)pml_req->req_peer_addr.lval;
desc->desc_buff = hdr;
LOG_PRINT(PTL_ELAN_DEBUG_PUT, " remote req %p addr %x, length %d\n",
pml_req->req_peer_match.pval,
pml_req->req_peer_addr.lval,
pml_req->req_peer_size);
/* FIXME: initialize convertor and get the fragment copied out */
if(size_in > 0 && 0) {
struct iovec iov;
ompi_convertor_t *convertor;
if( offset <= mca_ptl_elan_module.super.ptl_first_frag_size) {
convertor = &pml_req->req_convertor;
} else {
convertor = &frag->frag_base.frag_convertor;
ompi_convertor_copy(&pml_req->req_convertor, convertor);
ompi_convertor_init_for_send(
convertor,
0,
pml_req->req_base.req_datatype,
pml_req->req_base.req_count,
pml_req->req_base.req_addr,
offset);
}
/*
* TODO:
* For now, eager sends are always packed into the descriptor
* Inline up to 256 bytes (including the header), then
* do a chained send for mesg < first_frag_size */
/*desc->src_elan_addr = elan4_main2elan(ctx, desc->desc_buff);*/
iov.iov_base = desc->desc_buff;
iov.iov_len = size_in;
rc = ompi_convertor_pack(convertor, &iov, 1);
if (rc < 0) {
ompi_output (0, "[%s:%d] Unable to pack data\n",
__FILE__, __LINE__);
return;
}
size_out = iov.iov_len;
} else {
size_out = size_in;
}
/* FIXME:
* initialize convertor and get the fragment copied out
* use the convertor hanged over request */
size_out = size_in;
*size = size_out;
hdr->hdr_frag.hdr_frag_length = size_out;
/* Setup the chain dma */
desc->chain_dma.dma_typeSize = E4_DMA_TYPE_SIZE (
sizeof(mca_ptl_base_frag_header_t),
DMA_DataTypeByte, DMA_QueueWrite, 8);
@ -551,17 +486,11 @@ mca_ptl_elan_init_get_desc (struct mca_ptl_elan_send_frag_t *frag,
desc->chain_dma.dma_srcAddr = elan4_main2elan (ctx, (void *) hdr);
desc->chain_dma.dma_dstAddr = 0x0ULL;
desc->chain_dma.dma_srcEvent = elan4_main2elan (ctx, desc->elan_event);
/* causes the inputter to redirect the dma to the inputq */
desc->chain_dma.dma_dstEvent = elan4_main2elan (ctx,
(void *) ptl->queue->input);
INITEVENT_WORD (ctx, (E4_Event *) desc->elan_event, &desc->main_doneWord);
RESETEVENT_WORD (&desc->main_doneWord);
/* Be sure that padding E4_Event is not causing problems */
PRIMEEVENT_WORD (ctx, (E4_Event *)desc->elan_event, 1);
desc->chain_dma.dma_typeSize |= RUN_DMA_CMD;
desc->chain_dma.dma_pad = NOP_CMD;
@ -583,15 +512,15 @@ mca_ptl_elan_init_get_desc (struct mca_ptl_elan_send_frag_t *frag,
/* XXX: The chain dma will go directly into a command stream
* so we need addend the command queue control bits.
* Allocate space from command queues hanged off the CTX.
*/
* Allocate space from command queues hanged off the CTX. */
desc->chain_event->ev_Params[1] = elan4_alloccq_space (ctx, 8, CQ_Size8K);
/* FIXME: Find the correct addresses to fill in */
desc->main_dma.dma_srcAddr = desc->src_elan_addr;
desc->main_dma.dma_dstAddr = desc->dst_elan_addr;
desc->main_dma.dma_dstEvent= 0x0ULL; /*disable remote event */
desc->main_dma.dma_srcEvent= 0x0ULL; /*disable remote event */
/* Chain an event */
desc->main_dma.dma_srcEvent= elan4_main2elan(ctx,
desc->main_dma.dma_dstEvent= elan4_main2elan(ctx,
(E4_Event *)desc->chain_event);
/* FIXME: no additional flags for the DMA, remote, shmem, qwrite,
@ -599,25 +528,21 @@ mca_ptl_elan_init_get_desc (struct mca_ptl_elan_send_frag_t *frag,
flags = 0;
desc->main_dma.dma_typeSize = E4_DMA_TYPE_SIZE (size_out,
DMA_DataTypeByte, flags, ptl->putget->pg_retryCount);
desc->main_dma.dma_cookie = elan4_local_cookie (
desc->main_dma.dma_cookie = elan4_remote_cookie(
ptl->putget->pg_cpool,
E4_COOKIE_TYPE_LOCAL_DMA,
E4_COOKIE_TYPE_REMOTE_DMA,
destvp);
desc->main_dma.dma_vproc = destvp;
desc->main_dma.dma_vproc = ptl->elan_vp; /* target is self */
LOG_PRINT(PTL_ELAN_DEBUG_MAC,
"destvp %d type %d flag %d size %d\n",
destvp, hdr->hdr_common.hdr_type,
hdr->hdr_common.hdr_flags,
hdr->hdr_common.hdr_size);
/* Make main memory coherent with IO domain (IA64) */
MEMBAR_VISIBLE ();
END_FUNC(PTL_ELAN_DEBUG_SEND);
}
int
mca_ptl_elan_start_get (mca_ptl_elan_send_frag_t * desc,
mca_ptl_elan_start_get (mca_ptl_elan_send_frag_t * frag,
struct mca_ptl_elan_peer_t *ptl_peer,
struct mca_pml_base_recv_request_t *req,
size_t offset,
@ -629,21 +554,21 @@ mca_ptl_elan_start_get (mca_ptl_elan_send_frag_t * desc,
START_FUNC(PTL_ELAN_DEBUG_SEND);
ptl = ptl_peer->peer_ptl;
gdesc = (ompi_ptl_elan_putget_desc_t *)desc->desc;
gdesc = (ompi_ptl_elan_putget_desc_t *)frag->desc;
/*mca_ptl_elan_init_putget_desc */
mca_ptl_elan_init_get_desc (desc, ptl, ptl_peer,
sendreq, offset, size, flags);
mca_ptl_elan_init_get_desc (frag, ptl, ptl_peer,
req, offset, size, flags);
elan4_run_dma_cmd (ptl->putget->get_cmdq, (E4_DMA *) &gdesc->main_dma);
elan4_flush_cmdq_reorder (ptl->putget->get_cmdq);
ompi_list_append (&ptl->send_frags, (ompi_list_item_t *) desc);
ompi_list_append (&ptl->send_frags, (ompi_list_item_t *) frag);
desc->frag_base.frag_owner = (struct mca_ptl_base_module_t *)
frag->frag_base.frag_owner = (struct mca_ptl_base_module_t *)
&ptl_peer->peer_ptl->super;
desc->frag_base.frag_peer = (struct mca_ptl_base_peer_t *) ptl_peer;
desc->frag_base.frag_addr = NULL;
desc->frag_base.frag_size = *size;
desc->frag_progressed = 0;
desc->frag_ack_pending = 0; /* this is ack for internal elan */
frag->frag_base.frag_peer = (struct mca_ptl_base_peer_t *) ptl_peer;
frag->frag_base.frag_addr = NULL;
frag->frag_base.frag_size = *size;
frag->frag_progressed = 0;
frag->frag_ack_pending = 0; /* this is ack for internal elan */
END_FUNC(PTL_ELAN_DEBUG_SEND);
return OMPI_SUCCESS;
@ -652,7 +577,7 @@ mca_ptl_elan_start_get (mca_ptl_elan_send_frag_t * desc,
int
mca_ptl_elan_start_desc (mca_ptl_elan_send_frag_t * desc,
mca_ptl_elan_start_desc (mca_ptl_elan_send_frag_t * frag,
struct mca_ptl_elan_peer_t *ptl_peer,
struct mca_pml_base_send_request_t *sendreq,
size_t offset,
@ -665,28 +590,28 @@ mca_ptl_elan_start_desc (mca_ptl_elan_send_frag_t * desc,
START_FUNC(PTL_ELAN_DEBUG_SEND);
if (desc->desc->desc_type == MCA_PTL_ELAN_DESC_QDMA) {
if (frag->desc->desc_type == MCA_PTL_ELAN_DESC_QDMA) {
struct ompi_ptl_elan_qdma_desc_t *qdma;
qdma = (ompi_ptl_elan_qdma_desc_t *)desc->desc;
mca_ptl_elan_init_qdma_desc (desc, ptl, ptl_peer,
qdma = (ompi_ptl_elan_qdma_desc_t *)frag->desc;
mca_ptl_elan_init_qdma_desc (frag, ptl, ptl_peer,
sendreq, offset, size, flags);
elan4_run_dma_cmd (ptl->queue->tx_cmdq, (DMA *) & qdma->main_dma);
elan4_flush_cmdq_reorder (ptl->queue->tx_cmdq);
ompi_list_append (&ptl->send_frags, (ompi_list_item_t *) desc);
ompi_list_append (&ptl->send_frags, (ompi_list_item_t *) frag);
} else if (MCA_PTL_ELAN_DESC_PUT == desc->desc->desc_type) {
} else if (MCA_PTL_ELAN_DESC_PUT == frag->desc->desc_type) {
struct ompi_ptl_elan_putget_desc_t *pdesc;
pdesc = (ompi_ptl_elan_putget_desc_t *)desc->desc;
mca_ptl_elan_init_putget_desc (desc, ptl, ptl_peer, sendreq,
pdesc = (ompi_ptl_elan_putget_desc_t *)frag->desc;
mca_ptl_elan_init_putget_desc (frag, ptl, ptl_peer, sendreq,
offset, size, flags);
elan4_run_dma_cmd (ptl->putget->put_cmdq, (E4_DMA *) &pdesc->main_dma);
elan4_flush_cmdq_reorder (ptl->putget->put_cmdq);
/* Insert desc into the list of outstanding DMA's */
ompi_list_append (&ptl->send_frags, (ompi_list_item_t *) desc);
/* Insert frag into the list of outstanding DMA's */
ompi_list_append (&ptl->send_frags, (ompi_list_item_t *) frag);
} else {
ompi_output (0, "To support GET and Other types of DMA "
"are not supported right now \n");
@ -694,13 +619,13 @@ mca_ptl_elan_start_desc (mca_ptl_elan_send_frag_t * desc,
}
/* fragment state */
desc->frag_base.frag_owner = (struct mca_ptl_base_module_t *)
frag->frag_base.frag_owner = (struct mca_ptl_base_module_t *)
&ptl_peer->peer_ptl->super;
desc->frag_base.frag_peer = (struct mca_ptl_base_peer_t *) ptl_peer;
desc->frag_base.frag_addr = NULL;
desc->frag_base.frag_size = *size;
desc->frag_progressed = 0;
desc->frag_ack_pending = 0; /* this is ack for internal elan */
frag->frag_base.frag_peer = (struct mca_ptl_base_peer_t *) ptl_peer;
frag->frag_base.frag_addr = NULL;
frag->frag_base.frag_size = *size;
frag->frag_progressed = 0;
frag->frag_ack_pending = 0; /* this is ack for internal elan */
END_FUNC(PTL_ELAN_DEBUG_SEND);
return OMPI_SUCCESS;
@ -718,42 +643,33 @@ mca_ptl_elan_get_with_ack ( mca_ptl_base_module_t * ptl,
mca_pml_base_recv_request_t* request;
mca_ptl_elan_module_t *elan_ptl;
int destvp;
int remain_len, flags;
START_FUNC(PTL_ELAN_DEBUG_ACK);
flags = 0; /* XXX: No special flags for get */
elan_ptl = (mca_ptl_elan_module_t *) ptl;
destvp = ((mca_ptl_elan_peer_t *)
recv_frag->frag_recv.frag_base.frag_peer)->peer_vp;
frag->desc->desc_type = MCA_PTL_ELAN_DESC_QDMA;
gdesc = (ompi_ptl_elan_gdesc_desc_t *)frag->desc;
hdr = (mca_ptl_base_header_t *) &frag->frag_base.frag_header;
request = recv_frag->frag_recv.frag_request;
destvp = ((mca_ptl_elan_peer_t *)
recv_frag->frag_recv.frag_base.frag_peer)->peer_vp;
frag->desc->desc_type = MCA_PTL_ELAN_DESC_PUT;
gdesc = (ompi_ptl_elan_putget_desc_t *)frag->desc;
hdr = (mca_ptl_base_header_t *) &frag->frag_base.frag_header;
/* XXX: since send_frag provides a header inside,
* no need to allocate a buffer-equipped QDMA descriptor */
hdr->hdr_common.hdr_type = MCA_PTL_HDR_TYPE_ACK;
hdr->hdr_common.hdr_flags = 0;
* no need to allocate a QDMA descriptor w/ buff */
remain_len = request->req_bytes_packed - request->req_bytes_received;
hdr->hdr_common.hdr_type = MCA_PTL_HDR_TYPE_FIN;
hdr->hdr_common.hdr_flags= 0;
hdr->hdr_common.hdr_size = sizeof(mca_ptl_base_ack_header_t);
/* Remote send fragment descriptor */
hdr->hdr_ack.hdr_src_ptr =
recv_frag->frag_recv.frag_base.frag_header.hdr_frag.hdr_src_ptr;
/* Matched request from recv side */
hdr->hdr_ack.hdr_dst_match.lval = 0;
hdr->hdr_ack.hdr_dst_match.pval = request;
/* FIXME: this needs to be some offsete from the base addr */
hdr->hdr_ack.hdr_dst_addr.pval = 0;
hdr->hdr_ack.hdr_dst_addr.lval = elan4_main2elan(
elan_ptl->ptl_elan_ctx, request->req_base.req_addr);
/* FIXME: posted buffer size is the leftover */
hdr->hdr_ack.hdr_dst_size =
request->req_bytes_packed - request->req_bytes_received;
/* XXX: No need to set the fragment size */
/*hdr->hdr_common.hdr_frag_length = sizeof(mca_ptl_base_ack_header_t);*/
hdr->hdr_ack.hdr_dst_size = remain_len;
LOG_PRINT(PTL_ELAN_DEBUG_ACK,
"remote frag %p local req %p buffer %p size %d \n",
@ -762,35 +678,29 @@ mca_ptl_elan_get_with_ack ( mca_ptl_base_module_t * ptl,
hdr->hdr_ack.hdr_dst_addr.pval,
hdr->hdr_ack.hdr_dst_size);
/* Filling up QDMA descriptor */
gdesc->main_dma.dma_srcAddr = elan4_main2elan(
elan_ptl->ptl_elan_ctx, &gdesc->buff[0]);
mca_ptl_elan_init_get_desc (frag, ptl,
recv_frag->frag_recv.frag_base.frag_peer,
request, request->req_bytes_received,
remain_len, flags);
/* XXX: Hardcoded DMA retry count */
gdesc->main_dma.dma_typeSize = E4_DMA_TYPE_SIZE (
sizeof(mca_ptl_base_ack_header_t),
DMA_DataTypeByte, DMA_QueueWrite, 16);
gdesc->main_dma.dma_vproc = destvp;
gdesc->main_dma.dma_cookie = elan4_local_cookie (
elan_ptl->queue->tx_cpool,
E4_COOKIE_TYPE_LOCAL_DMA, destvp);
/* Make main memory coherent with IO domain (IA64) */
MEMBAR_VISIBLE ();
elan4_run_dma_cmd (elan_ptl->queue->tx_cmdq, (DMA *) & gdesc->main_dma);
elan4_flush_cmdq_reorder (elan_ptl->queue->tx_cmdq);
/* Insert frag into the list of outstanding DMA's */
/* Trigger a STEN packet to the remote side and then from there
* a elan_get is triggered */
elan4_remote_dma(elan_ptl->putget->get_cmdq,
(E4_DMA *)&gdesc->main_dma, destvp,
elan4_local_cookie(elan_ptl->putget->pg_cpool,
E4_COOKIE_TYPE_STEN , destvp));
elan4_flush_cmdq_reorder (elan_ptl->putget->get_cmdq);
MEMBAR_DRAIN();
ompi_list_append (&elan_ptl->send_frags, (ompi_list_item_t *) frag);
/* fragment state */
frag->desc->req = NULL;
frag->frag_base.frag_owner = ptl;
frag->frag_base.frag_peer = recv_frag->frag_recv.frag_base.frag_peer;
frag->frag_base.frag_addr = NULL;
frag->frag_base.frag_size = 0;
frag->frag_progressed = 0;
/* XXX: fragment state, remember the recv_frag may be gone */
frag->desc->req = (mca_pml_base_request_t *) request ; /*recv req*/
frag->desc->desc_status = MCA_PTL_ELAN_DESC_LOCAL;
frag->frag_base.frag_owner= ptl;
frag->frag_base.frag_peer = recv_frag->frag_recv.frag_base.frag_peer;
frag->frag_base.frag_addr = request->req_base.req_addr;/*final buff*/
frag->frag_base.frag_size = remain_len;
frag->frag_progressed = 0;
END_FUNC(PTL_ELAN_DEBUG_ACK);
return OMPI_SUCCESS;
@ -842,9 +752,6 @@ mca_ptl_elan_start_ack ( mca_ptl_base_module_t * ptl,
hdr->hdr_ack.hdr_dst_size =
request->req_bytes_packed - request->req_bytes_received;
/* XXX: No need to set the fragment size */
/*hdr->hdr_common.hdr_frag_length = sizeof(mca_ptl_base_ack_header_t);*/
LOG_PRINT(PTL_ELAN_DEBUG_ACK,
"remote frag %p local req %p buffer %p size %d \n",
hdr->hdr_ack.hdr_src_ptr.pval,
@ -1009,12 +916,12 @@ mca_ptl_elan_update_desc (mca_ptl_elan_component_t * emp)
rc = elan4_pollevent_word(ctx, &frag->desc->main_doneWord, 1);
#endif
if (rc) {
struct ompi_ptl_elan_base_desc_t *basic;
ompi_ptl_elan_base_desc_t *basic;
/* Remove the desc, update the request, return to free list */
frag = (mca_ptl_elan_send_frag_t *)
ompi_list_remove_first (&ptl->send_frags);
basic = (ompi_ptl_elan_qdma_desc_t*)frag->desc;
basic = (ompi_ptl_elan_base_desc_t*)frag->desc;
mca_ptl_elan_send_desc_done (frag, basic->req);
INITEVENT_WORD (ctx, basic->elan_event, &basic->main_doneWord);
RESETEVENT_WORD (&basic->main_doneWord);

20
src/mca/ptl/elan/src/ptl_elan_priv.h
Просмотреть файл

@ -69,7 +69,8 @@
#define OMPI_PTL_ELAN_GET_MIN(a,b) ((a<b)? a:b)
#define OMPI_PTL_ELAN_ALIGNUP(x,a) (((unsigned int)(x) + ((a)-1)) & (-(a)))
#define OMPI_PTL_ELAN_ENABLE_GET (0)
#define OMPI_PTL_ELAN_ENABLE_GET (1)
#define OMPI_PTL_ELAN_QDMA_RETRY (16)
/* For now only debug send's */
#if 1
@ -167,7 +168,7 @@ typedef struct ompi_ptl_elan_recv_queue_t ompi_ptl_elan_recv_queue_t;
volatile E4_uint64 main_doneWord; \
/* 8 byte aligned */ \
E4_Event *elan_event; \
uint8_t *desc_buff; \
void *desc_buff; \
/* 8 byte aligned */ \
mca_pml_base_request_t *req; \
mca_ptl_elan_module_t *ptl; \
@ -321,7 +322,8 @@ int ompi_init_elan_stat (mca_ptl_elan_component_t * emp,
int num_rails);
/* communication prototypes */
int mca_ptl_elan_start_desc(mca_ptl_elan_send_frag_t *desc,
int mca_ptl_elan_start_desc(
mca_ptl_elan_send_frag_t *desc,
struct mca_ptl_elan_peer_t *ptl_peer,
struct mca_pml_base_send_request_t *sendreq,
size_t offset,
@ -331,6 +333,9 @@ int mca_ptl_elan_start_desc(mca_ptl_elan_send_frag_t *desc,
int mca_ptl_elan_start_ack ( mca_ptl_base_module_t * ptl,
mca_ptl_elan_send_frag_t * desc,
mca_ptl_elan_recv_frag_t * recv_frag);
int mca_ptl_elan_get_with_ack (mca_ptl_base_module_t * ptl,
mca_ptl_elan_send_frag_t * frag,
mca_ptl_elan_recv_frag_t * recv_frag);
int mca_ptl_elan_poll_desc(mca_ptl_elan_send_frag_t *desc);
int mca_ptl_elan_wait_desc(mca_ptl_elan_send_frag_t *desc);
@ -338,6 +343,15 @@ int mca_ptl_elan_wait_desc(mca_ptl_elan_send_frag_t *desc);
/* control, synchronization and state prototypes */
int mca_ptl_elan_drain_recv(mca_ptl_elan_component_t *emp);
int mca_ptl_elan_update_desc(mca_ptl_elan_component_t *emp);
int
mca_ptl_elan_start_get (mca_ptl_elan_send_frag_t * frag,
struct mca_ptl_elan_peer_t *ptl_peer,
struct mca_pml_base_recv_request_t *req,
size_t offset,
size_t *size,
int flags);
/**
* utility routines for parameter registration
*/