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

Adapt to the new datatype engine

Просмотр исходного кода 
Remove some of the compiler warnings

This commit was SVN r3057.
Этот коммит содержится в:
George Bosilca 2004-10-12 04:17:29 +00:00
родитель 37419ffc5f
Коммит 0385f4b87d
9 изменённых файлов: 268 добавлений и 274 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

16
src/mca/ptl/gm/src/ptl_gm.c
Просмотреть файл

@ -1,3 +1,5 @@
/* -*- Mode: C; c-basic-offset:4 ; -*- */
/*
* $HEADER$
*/
@ -220,8 +222,8 @@ mca_ptl_gm_send (struct mca_ptl_base_module_t *ptl,
gm_ptl = (mca_ptl_gm_module_t *)ptl;
if (offset == 0)
{
GM_DBG(PTL_GM_DBG_COMM,"INSIDE PTL GM SEND, OFFSET = 0,request is %p
frag is %p\n",sendreq,((mca_ptl_gm_send_request_t *)sendreq)->req_frag);
GM_DBG(PTL_GM_DBG_COMM,"INSIDE PTL GM SEND, OFFSET = 0,request is %p frag is %p\n",
(void*)sendreq, (void*)((mca_ptl_gm_send_request_t *)sendreq)->req_frag);
#if 0
sendfrag = ((mca_ptl_gm_send_request_t *)sendreq)->req_frag;
@ -411,6 +413,9 @@ mca_ptl_gm_matched( mca_ptl_base_module_t * ptl,
if (header->hdr_frag.hdr_frag_length > 0)
{
ompi_proc_t *proc;
unsigned int max_data, out_size;
int freeAfter;
proc = ompi_comm_peer_lookup(request->req_base.req_comm,
request->req_base.req_peer);
ompi_convertor_copy(proc->proc_convertor,
@ -421,8 +426,11 @@ mca_ptl_gm_matched( mca_ptl_base_module_t * ptl,
request->req_base.req_datatype,
request->req_base.req_count,
request->req_base.req_addr,
header->hdr_frag.hdr_frag_offset);
rc = ompi_convertor_unpack(&frag->frag_base.frag_convertor, &(iov), 1);
header->hdr_frag.hdr_frag_offset, NULL );
out_size = 1;
max_data = iov.iov_len;
rc = ompi_convertor_unpack( &frag->frag_base.frag_convertor, &(iov),
&out_size, &max_data, &freeAfter );
assert( rc >= 0 );
A_PRINT("in matched: bytes received is %d\n", bytes_recv);
}

2
src/mca/ptl/gm/src/ptl_gm_component.c
Просмотреть файл

@ -1,3 +1,5 @@
/* -*- Mode: C; c-basic-offset:4 ; -*- */
/*
* $HEADER$
*/

2
src/mca/ptl/gm/src/ptl_gm_peer.h
Просмотреть файл

@ -1,3 +1,5 @@
/* -*- Mode: C; c-basic-offset:4 ; -*- */
/*
* $HEADER$
*/

145
src/mca/ptl/gm/src/ptl_gm_priv.c
Просмотреть файл

@ -1,3 +1,4 @@
/* -*- Mode: C; c-basic-offset:4 ; -*- */
/*
* $HEADER$
@ -34,9 +35,9 @@ int mca_ptl_gm_peer_put(mca_ptl_gm_peer_t *ptl_peer,
{
gm_put( ptl_peer->peer_ptl->my_port, fragment->registered_buf,
(gm_remote_ptr_t) target_buffer,bytes, GM_LOW_PRIORITY,
ptl_peer->local_id, ptl_peer->port_number,
put_callback, (void *)fragment );
(gm_remote_ptr_t)target_buffer, bytes, GM_LOW_PRIORITY,
ptl_peer->local_id, ptl_peer->port_number,
put_callback, (void *)fragment );
fragment->send_frag.frag_base.frag_owner = &ptl_peer->peer_ptl->super;
@ -76,7 +77,8 @@ int mca_ptl_gm_peer_send(mca_ptl_gm_peer_t *ptl_peer,
if(size_in > 0) {
ompi_convertor_t *convertor;
int rc;
int rc, freeAfter;
unsigned int in_size, max_data;
/* first fragment (eager send) and first fragment of long protocol
* can use the convertor initialized on the request, remaining
@ -94,7 +96,7 @@ int mca_ptl_gm_peer_send(mca_ptl_gm_peer_t *ptl_peer,
sendreq->req_base.req_datatype,
sendreq->req_base.req_count,
sendreq->req_base.req_addr,
offset);
offset, NULL );
}
/* if data is contigous convertor will return an offset
@ -104,8 +106,9 @@ int mca_ptl_gm_peer_send(mca_ptl_gm_peer_t *ptl_peer,
/*copy the data to the registered buffer*/
outvec.iov_base = ((char*)fragment->send_buf) + header_length;
if((rc = ompi_convertor_pack(convertor, &(outvec), 1)) < 0)
max_data = outvec.iov_len;
in_size = 1;
if((rc = ompi_convertor_pack(convertor, &(outvec), &in_size, &max_data, &freeAfter)) < 0)
return OMPI_ERROR;
}
/* update the fields */
@ -116,9 +119,9 @@ int mca_ptl_gm_peer_send(mca_ptl_gm_peer_t *ptl_peer,
* packed by convertor */
size_out = outvec.iov_len;
A_PRINT(" inside peer_send request is %p\t, frag->req = %p, fragment is
%p,size is %d, send_frag is %p\n",sendreq, fragment->req,fragment,size_out,
((mca_ptl_base_header_t *)header)->hdr_ack.hdr_src_ptr);
A_PRINT( "peer_send request is %p\t, frag->req = %p, fragment is %p,size is %d, send_frag is %p\n",
sendreq, fragment->req,fragment,size_out,
((mca_ptl_base_header_t *)header)->hdr_ack.hdr_src_ptr);
/* initiate the gm send */
gm_send_with_callback( ptl_peer->peer_ptl->my_port, fragment->send_buf,
@ -127,7 +130,7 @@ int mca_ptl_gm_peer_send(mca_ptl_gm_peer_t *ptl_peer,
fragment->send_frag.frag_base.frag_owner = &ptl_peer->peer_ptl->super;
fragment->send_frag.frag_base.frag_peer = (struct mca_ptl_base_peer_t*)ptl_peer;
fragment->send_frag.frag_base.frag_addr = outvec.iov_base + header_length;
fragment->send_frag.frag_base.frag_addr = ((char*)outvec.iov_base) + header_length;
fragment->send_frag.frag_base.frag_size = size_out - header_length;
#if 1
@ -234,7 +237,7 @@ void send_callback(struct gm_port *port,void * context, gm_status_t status)
else if(header->hdr_common.hdr_type == MCA_PTL_HDR_TYPE_FIN)
{
A_PRINT("send callback : Completion of fin, bytes complete =
A_PRINT("send callback : Completion of fin, bytes complete =\
%d\n",header->hdr_ack.hdr_dst_size);
ptl->super.ptl_send_progress( (mca_ptl_base_module_t*)ptl, frag->send_frag.frag_request,
header->hdr_ack.hdr_dst_size);
@ -265,8 +268,7 @@ void send_callback(struct gm_port *port,void * context, gm_status_t status)
/* Not going to call progress on this send,
* and not free-ing descriptor */
frag->send_complete = 1;
A_PRINT("send callback : match required but not yet recv ack
sendfrag is %p\n",frag);
A_PRINT("send callback : match required but not yet recv ack sendfrag is %p\n",frag);
}
break;
@ -304,10 +306,8 @@ void send_callback(struct gm_port *port,void * context, gm_status_t status)
frag = (mca_ptl_gm_send_frag_t *)context;
ptl = (mca_ptl_gm_module_t *)frag->send_frag.frag_base.frag_owner;
gm_send_req = frag->req;
GM_DBG(PTL_GM_DBG_COMM,"INSIDE SENDCALLBACK request is %p\t, frag->req =
%p, frag is %p \n",gm_send_req, frag->req,frag);
GM_DBG(PTL_GM_DBG_COMM,"INSIDE SENDCALLBACK request is %p\t, frag->req = %p, frag is %p\n",
gm_send_req, frag->req,frag);
header = (mca_ptl_base_header_t*)frag->send_buf;
header_length = ((mca_ptl_base_header_t*)header)->hdr_common.hdr_size;
@ -391,73 +391,72 @@ void send_callback(struct gm_port *port,void * context, gm_status_t status)
void ptl_gm_ctrl_frag(struct mca_ptl_gm_module_t *ptl,
mca_ptl_base_header_t * header)
{
mca_ptl_gm_send_frag_t * frag;
mca_pml_base_send_request_t *req;
mca_pml_base_recv_request_t *request;
int header_length, bytes;
char * reg_buf;
int status;
mca_ptl_gm_send_frag_t * frag;
mca_pml_base_send_request_t *req;
mca_pml_base_recv_request_t *request;
int header_length, bytes;
char * reg_buf;
int status;
if(header->hdr_common.hdr_type == MCA_PTL_HDR_TYPE_ACK)
{
A_PRINT("ack header is %d, frag_ptr is
%p\n",header->hdr_common.hdr_size,header->hdr_ack.hdr_src_ptr.pval);
frag = (mca_ptl_gm_send_frag_t *)(header->hdr_ack.hdr_src_ptr.pval);
A_PRINT("inside ACK, corresp frag pointer %p\n",frag);
req = (mca_pml_base_send_request_t *) frag->req;
assert(req != NULL);
req->req_peer_match.pval = header->hdr_ack.hdr_dst_match.pval;
req->req_peer_addr.pval = header->hdr_ack.hdr_dst_addr.pval;
req->req_peer_size = header->hdr_ack.hdr_dst_size;
frag->wait_for_ack = 0;
header_length = frag->send_frag.frag_base.frag_header.hdr_frag.hdr_common.hdr_size;
bytes = frag->send_frag.frag_base.frag_size;
if(frag->send_complete == 1)
if(header->hdr_common.hdr_type == MCA_PTL_HDR_TYPE_ACK)
{
ptl->super.ptl_send_progress( (mca_ptl_base_module_t*)ptl,
frag->send_frag.frag_request,bytes);
A_PRINT( "ack header is %d, frag_ptr is %p\n", header->hdr_common.hdr_size,
header->hdr_ack.hdr_src_ptr.pval);
frag = (mca_ptl_gm_send_frag_t *)(header->hdr_ack.hdr_src_ptr.pval);
A_PRINT("inside ACK, corresp frag pointer %p\n",frag);
req = (mca_pml_base_send_request_t *) frag->req;
assert(req != NULL);
req->req_peer_match.pval = header->hdr_ack.hdr_dst_match.pval;
req->req_peer_addr.pval = header->hdr_ack.hdr_dst_addr.pval;
req->req_peer_size = header->hdr_ack.hdr_dst_size;
frag->wait_for_ack = 0;
OMPI_FREE_LIST_RETURN(&(ptl->gm_send_frags), (ompi_list_item_t *)frag);
A_PRINT("inside ACK,returning frag pointer %p, request is %p, bytes
is %d\n",frag, frag->send_frag.frag_request, header->hdr_frag.hdr_frag_length );
header_length = frag->send_frag.frag_base.frag_header.hdr_frag.hdr_common.hdr_size;
bytes = frag->send_frag.frag_base.frag_size;
if(frag->send_complete == 1)
{
ptl->super.ptl_send_progress( (mca_ptl_base_module_t*)ptl,
frag->send_frag.frag_request,bytes);
OMPI_FREE_LIST_RETURN(&(ptl->gm_send_frags), (ompi_list_item_t *)frag);
A_PRINT( "inside ACK,returning frag pointer %p, request is %p, bytes is %d\n",
frag, frag->send_frag.frag_request, header->hdr_frag.hdr_frag_length );
}
}
}
if(header->hdr_common.hdr_type == MCA_PTL_HDR_TYPE_FIN)
{
if(header->hdr_common.hdr_type == MCA_PTL_HDR_TYPE_FIN)
{
GM_DBG(PTL_GM_DBG_COMM,"CASE: HDR_TYPE_FIN\n");
request = (mca_pml_base_recv_request_t*)
header->hdr_ack.hdr_dst_match.pval;
/* call receive progress and indicate the recv has been completed */
GM_DBG(PTL_GM_DBG_COMM,"CASE: HDR_TYPE_FIN\n");
request = (mca_pml_base_recv_request_t*)
header->hdr_ack.hdr_dst_match.pval;
/* call receive progress and indicate the recv has been completed */
GM_DBG(PTL_GM_DBG_COMM,"Calling recv_progress with bytes = %d\n",header->hdr_ack.hdr_dst_size);
ptl->super.ptl_recv_progress (
(mca_ptl_base_module_t *) ptl,
request ,
header->hdr_ack.hdr_dst_size,
header->hdr_ack.hdr_dst_size);
GM_DBG(PTL_GM_DBG_COMM,"Calling recv_progress with bytes = %d\n",header->hdr_ack.hdr_dst_size);
ptl->super.ptl_recv_progress (
(mca_ptl_base_module_t *) ptl,
request ,
header->hdr_ack.hdr_dst_size,
header->hdr_ack.hdr_dst_size);
/* deregister the memory */
bytes = header->hdr_ack.hdr_dst_size;
reg_buf =(char *) header->hdr_ack.hdr_dst_addr.pval;
status = gm_deregister_memory(ptl->my_port, reg_buf, bytes);
bytes = header->hdr_ack.hdr_dst_size;
reg_buf =(char *) header->hdr_ack.hdr_dst_addr.pval;
status = gm_deregister_memory(ptl->my_port, reg_buf, bytes);
if(GM_SUCCESS != status)
{
ompi_output(0," unpinning memory failed\n");
}
else
{
GM_DBG(PTL_GM_DBG_COMM, "unpinning memory success,addr:%p,bytes:%d\n",reg_buf,bytes);
}
if(GM_SUCCESS != status)
{
ompi_output(0," unpinning memory failed\n");
}
else
{
GM_DBG(PTL_GM_DBG_COMM, "unpinning memory success,addr:%p,bytes:%d\n",reg_buf,bytes);
}
}
}
}

2
src/mca/ptl/gm/src/ptl_gm_priv.h
Просмотреть файл

@ -1,3 +1,5 @@
/* -*- Mode: C; c-basic-offset:4 ; -*- */
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>

2
src/mca/ptl/gm/src/ptl_gm_proc.c
Просмотреть файл

@ -1,3 +1,5 @@
/* -*- Mode: C; c-basic-offset:4 ; -*- */
/*
* $HEADER$
*/

2
src/mca/ptl/gm/src/ptl_gm_proc.h
Просмотреть файл

@ -1,3 +1,5 @@
/* -*- Mode: C; c-basic-offset:4 ; -*- */
/*
* $HEADER$
*/

2
src/mca/ptl/gm/src/ptl_gm_req.h
Просмотреть файл

@ -1,3 +1,5 @@
/* -*- Mode: C; c-basic-offset:4 ; -*- */
/*
*HEADER$
*/

341
src/mca/ptl/gm/src/ptl_gm_sendfrag.c
Просмотреть файл

@ -1,3 +1,5 @@
/* -*- Mode: C; c-basic-offset:4 ; -*- */
/*
*HEADER$
*/
@ -38,20 +40,16 @@ mca_ptl_gm_send_frag_construct (mca_ptl_gm_send_frag_t * frag)
{
}
static void
mca_ptl_gm_send_frag_destruct (mca_ptl_gm_send_frag_t * frag)
{
}
/*XXX : take care of multi threading*/
mca_ptl_gm_send_frag_t *
mca_ptl_gm_alloc_send_frag(struct mca_ptl_base_module_t *ptl,
struct mca_pml_base_send_request_t * sendreq)
mca_ptl_gm_alloc_send_frag( struct mca_ptl_base_module_t *ptl,
struct mca_pml_base_send_request_t * sendreq )
{
ompi_free_list_t *flist;
@ -69,205 +67,186 @@ mca_ptl_gm_alloc_send_frag(struct mca_ptl_base_module_t *ptl,
A_PRINT("send_frag: %p\n", item);
A_PRINT("after removing a sendfrag num_list_allocated: %d\n",flist->fl_num_allocated);
while(NULL == item)
{
A_PRINT("888888888888888888888888 calling progress to allocate send frag\n");
ptl->ptl_component->ptlm_progress(tstamp);
item = ompi_list_remove_first (&((flist)->super));
while(NULL == item) {
A_PRINT("888888888888888888888888 calling progress to allocate send frag\n");
ptl->ptl_component->ptlm_progress(tstamp);
item = ompi_list_remove_first (&((flist)->super));
}
frag = (mca_ptl_gm_send_frag_t *)item;
frag->req = (struct mca_pml_base_send_request_t *)sendreq;
GM_DBG(PTL_GM_DBG_COMM, "request is %p\t, frag->req = %p\n",sendreq, frag->req);
GM_DBG( PTL_GM_DBG_COMM, "request is %p\t, frag->req = %p\n", (void*)sendreq, (void*)frag->req );
frag->type = 0 ;
return frag;
}
int mca_ptl_gm_send_frag_done( mca_ptl_gm_send_frag_t * frag,
mca_pml_base_send_request_t * req )
{
return OMPI_SUCCESS;
}
int mca_ptl_gm_send_ack_init( struct mca_ptl_gm_send_frag_t* ack,
mca_ptl_gm_module_t *ptl,
mca_ptl_gm_peer_t* ptl_peer,
struct mca_ptl_gm_recv_frag_t* frag,
char * buffer,
int size )
{
mca_ptl_base_header_t * hdr;
mca_pml_base_recv_request_t *request;
hdr = (mca_ptl_base_header_t *)ack->send_buf;
memset(hdr, 0, sizeof(mca_ptl_base_ack_header_t));
ack->status = -1;
ack->type = -1;
ack->wait_for_ack = 0;
ack->put_sent = -1;
ack->send_complete = -1;
GM_DBG(PTL_GM_DBG_COMM,"ack buf is %p\n",ack->send_buf);
request = frag->frag_recv.frag_request;
hdr->hdr_common.hdr_type = MCA_PTL_HDR_TYPE_ACK;
hdr->hdr_common.hdr_flags = 0;
hdr->hdr_common.hdr_size = sizeof(mca_ptl_base_ack_header_t);
hdr->hdr_ack.hdr_src_ptr.pval =
frag->frag_recv.frag_base.frag_header.hdr_frag.hdr_src_ptr.pval;
A_PRINT("inside ack init: the src frag ptr is %p,hdr_len is %u\n",
hdr->hdr_ack.hdr_src_ptr,hdr->hdr_common.hdr_size);
hdr->hdr_ack.hdr_dst_match.lval = 0;
hdr->hdr_ack.hdr_dst_match.pval = request; /*should this be dst_match */
hdr->hdr_ack.hdr_dst_addr.lval = 0; /*we are filling both p and val of dest address */
hdr->hdr_ack.hdr_dst_addr.pval = (void *)buffer;
hdr->hdr_ack.hdr_dst_size = size;
ack->send_frag.frag_request = 0;
ack->send_frag.frag_base.frag_peer = (struct mca_ptl_base_peer_t *)ptl_peer;
ack->send_frag.frag_base.frag_owner = (mca_ptl_base_module_t *)ptl;
ack->send_frag.frag_base.frag_addr = NULL;
ack->send_frag.frag_base.frag_size = 0;
ack->status = 1; /* was able to register memory */
ack->ptl = ptl;
ack->send_frag.frag_base.frag_header = *hdr;
ack->wait_for_ack = 0;
ack->type = ACK;
return OMPI_SUCCESS;
}
int mca_ptl_gm_send_frag_done(
mca_ptl_gm_send_frag_t * frag,
mca_pml_base_send_request_t * req)
int mca_ptl_gm_put_frag_init( mca_ptl_gm_send_frag_t* putfrag,
mca_ptl_gm_peer_t * ptl_peer,
mca_ptl_gm_module_t * gm_ptl,
mca_pml_base_send_request_t * request,
size_t offset,
size_t* size,
int flags )
{
mca_ptl_base_header_t *hdr;
hdr = (mca_ptl_base_header_t *)putfrag->send_buf;
memset(hdr, 0, sizeof(mca_ptl_base_header_t));
putfrag->status = -1;
putfrag->type = -1;
putfrag->wait_for_ack = 0;
putfrag->put_sent = -1;
putfrag->send_complete = -1;
return OMPI_SUCCESS;
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);
hdr->hdr_ack.hdr_dst_match.lval = 0;
hdr->hdr_ack.hdr_dst_match.pval = request->req_peer_match.pval;
hdr->hdr_ack.hdr_dst_addr.lval = 0;
hdr->hdr_ack.hdr_dst_addr.pval = (void *)(request->req_peer_addr.pval);
hdr->hdr_ack.hdr_dst_size = *size;
putfrag->send_frag.frag_request = request;
putfrag->send_frag.frag_base.frag_peer = (struct mca_ptl_base_peer_t *)ptl_peer;
putfrag->send_frag.frag_base.frag_owner = (mca_ptl_base_module_t *)gm_ptl;
putfrag->send_frag.frag_base.frag_addr = NULL;
putfrag->send_frag.frag_base.frag_size = 0;
putfrag->ptl = gm_ptl;
putfrag->wait_for_ack = 0;
putfrag->put_sent = 0;
putfrag->type = PUT;
putfrag->req = request;
assert(putfrag->req != NULL);
return OMPI_SUCCESS;
}
int mca_ptl_gm_send_ack_init(
struct mca_ptl_gm_send_frag_t* ack,
mca_ptl_gm_module_t *ptl,
mca_ptl_gm_peer_t* ptl_peer,
struct mca_ptl_gm_recv_frag_t* frag,
char * buffer,
int size)
{
mca_ptl_base_header_t * hdr;
mca_pml_base_recv_request_t *request;
hdr = (mca_ptl_base_header_t *)ack->send_buf;
memset(hdr, 0, sizeof(mca_ptl_base_ack_header_t));
ack->status = -1;
ack->type = -1;
ack->wait_for_ack = 0;
ack->put_sent = -1;
ack->send_complete = -1;
GM_DBG(PTL_GM_DBG_COMM,"ack buf is %p\n",ack->send_buf);
request = frag->frag_recv.frag_request;
hdr->hdr_common.hdr_type = MCA_PTL_HDR_TYPE_ACK;
hdr->hdr_common.hdr_flags = 0;
hdr->hdr_common.hdr_size = sizeof(mca_ptl_base_ack_header_t);
hdr->hdr_ack.hdr_src_ptr.pval =
frag->frag_recv.frag_base.frag_header.hdr_frag.hdr_src_ptr.pval;
A_PRINT("inside ack init: the src frag ptr is %p,hdr_len is %u
\n",hdr->hdr_ack.hdr_src_ptr,hdr->hdr_common.hdr_size);
/*assert(((mca_ptl_gm_send_frag_t *)(hdr->hdr_ack.hdr_src_ptr.pval))->req
* != NULL);*/
hdr->hdr_ack.hdr_dst_match.lval = 0;
hdr->hdr_ack.hdr_dst_match.pval = request; /*should this be dst_match */
hdr->hdr_ack.hdr_dst_addr.lval = 0; /*we are filling both p and val of dest address */
hdr->hdr_ack.hdr_dst_addr.pval = (void *)buffer;
hdr->hdr_ack.hdr_dst_size = size;
ack->send_frag.frag_request = 0;
ack->send_frag.frag_base.frag_peer = (struct mca_ptl_base_peer_t *)ptl_peer;
ack->send_frag.frag_base.frag_owner = (mca_ptl_base_module_t *)ptl;
ack->send_frag.frag_base.frag_addr = NULL;
ack->send_frag.frag_base.frag_size = 0;
ack->status = 1; /* was able to register memory */
ack->ptl = ptl;
ack->send_frag.frag_base.frag_header = *hdr;
ack->wait_for_ack = 0;
ack->type = ACK;
return OMPI_SUCCESS;
}
int mca_ptl_gm_put_frag_init(
mca_ptl_gm_send_frag_t* putfrag,
mca_ptl_gm_peer_t * ptl_peer,
mca_ptl_gm_module_t * gm_ptl,
mca_pml_base_send_request_t * request,
size_t offset,
size_t* size,
int flags)
{
mca_ptl_base_header_t *hdr;
hdr = (mca_ptl_base_header_t *)putfrag->send_buf;
memset(hdr, 0, sizeof(mca_ptl_base_header_t));
putfrag->status = -1;
putfrag->type = -1;
putfrag->wait_for_ack = 0;
putfrag->put_sent = -1;
putfrag->send_complete = -1;
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);
hdr->hdr_ack.hdr_dst_match.lval = 0;
hdr->hdr_ack.hdr_dst_match.pval = request->req_peer_match.pval;
hdr->hdr_ack.hdr_dst_addr.lval = 0;
hdr->hdr_ack.hdr_dst_addr.pval = (void *)(request->req_peer_addr.pval);
hdr->hdr_ack.hdr_dst_size = *size;
putfrag->send_frag.frag_request = request;
putfrag->send_frag.frag_base.frag_peer = (struct mca_ptl_base_peer_t *)ptl_peer;
putfrag->send_frag.frag_base.frag_owner = (mca_ptl_base_module_t *)gm_ptl;
putfrag->send_frag.frag_base.frag_addr = NULL;
putfrag->send_frag.frag_base.frag_size = 0;
putfrag->ptl = gm_ptl;
putfrag->wait_for_ack = 0;
putfrag->put_sent = 0;
putfrag->type = PUT;
putfrag->req = request;
assert(putfrag->req != NULL);
return OMPI_SUCCESS;
}
int mca_ptl_gm_send_frag_init(
mca_ptl_gm_send_frag_t* sendfrag,
mca_ptl_gm_peer_t * ptl_peer,
mca_pml_base_send_request_t * sendreq,
size_t offset,
size_t* size,
int flags)
int mca_ptl_gm_send_frag_init( mca_ptl_gm_send_frag_t* sendfrag,
mca_ptl_gm_peer_t * ptl_peer,
mca_pml_base_send_request_t * sendreq,
size_t offset,
size_t* size,
int flags )
{
mca_ptl_base_header_t *hdr;
void *buffer;
mca_ptl_base_header_t *hdr;
void *buffer;
buffer = sendfrag->send_buf;
hdr = (mca_ptl_base_header_t *)sendfrag->send_buf;
memset(hdr, 0, sizeof(mca_ptl_base_header_t));
buffer = sendfrag->send_buf;
hdr = (mca_ptl_base_header_t *)sendfrag->send_buf;
memset(hdr, 0, sizeof(mca_ptl_base_header_t));
sendfrag->status = -1;
sendfrag->type = -1;
sendfrag->wait_for_ack = 0;
sendfrag->put_sent = -1;
sendfrag->send_complete = -1;
assert(sendfrag->req != NULL);
sendfrag->status = -1;
sendfrag->type = -1;
sendfrag->wait_for_ack = 0;
sendfrag->put_sent = -1;
sendfrag->send_complete = -1;
assert(sendfrag->req != NULL);
if (offset == 0)
{
hdr->hdr_common.hdr_type = MCA_PTL_HDR_TYPE_MATCH;
hdr->hdr_common.hdr_flags = flags;
hdr->hdr_common.hdr_size = sizeof(mca_ptl_base_match_header_t);
if (offset == 0) {
hdr->hdr_common.hdr_type = MCA_PTL_HDR_TYPE_MATCH;
hdr->hdr_common.hdr_flags = flags;
hdr->hdr_common.hdr_size = sizeof(mca_ptl_base_match_header_t);
hdr->hdr_frag.hdr_frag_offset = offset;
hdr->hdr_frag.hdr_frag_seq = 0;
hdr->hdr_frag.hdr_dst_ptr.lval = 0;
hdr->hdr_frag.hdr_src_ptr.lval = 0;
hdr->hdr_frag.hdr_src_ptr.pval = sendfrag; /* pointer to the frag */
hdr->hdr_frag.hdr_frag_offset = offset;
hdr->hdr_frag.hdr_frag_seq = 0;
hdr->hdr_frag.hdr_dst_ptr.lval = 0;
hdr->hdr_frag.hdr_src_ptr.lval = 0;
hdr->hdr_frag.hdr_src_ptr.pval = sendfrag; /* pointer to the frag */
hdr->hdr_frag.hdr_frag_length = *size;
hdr->hdr_frag.hdr_frag_length = *size;
hdr->hdr_match.hdr_contextid = sendreq->req_base.req_comm->c_contextid;
hdr->hdr_match.hdr_src = sendreq->req_base.req_comm->c_my_rank;
hdr->hdr_match.hdr_dst = sendreq->req_base.req_peer;
hdr->hdr_match.hdr_tag = sendreq->req_base.req_tag;
hdr->hdr_match.hdr_msg_length= sendreq->req_bytes_packed;
hdr->hdr_match.hdr_msg_seq = sendreq->req_base.req_sequence;
hdr->hdr_match.hdr_contextid = sendreq->req_base.req_comm->c_contextid;
hdr->hdr_match.hdr_src = sendreq->req_base.req_comm->c_my_rank;
hdr->hdr_match.hdr_dst = sendreq->req_base.req_peer;
hdr->hdr_match.hdr_tag = sendreq->req_base.req_tag;
hdr->hdr_match.hdr_msg_length= sendreq->req_bytes_packed;
hdr->hdr_match.hdr_msg_seq = sendreq->req_base.req_sequence;
#if 1
hdr->hdr_frag.hdr_dst_ptr.lval = 0;
#endif
#if 1
hdr->hdr_frag.hdr_dst_ptr.lval = 0;
#endif
} else {
hdr->hdr_common.hdr_type = MCA_PTL_HDR_TYPE_FRAG;
hdr->hdr_common.hdr_flags = flags;
hdr->hdr_common.hdr_size = sizeof (mca_ptl_base_frag_header_t);
}
else
{
hdr->hdr_common.hdr_type = MCA_PTL_HDR_TYPE_FRAG;
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 = sendfrag;
hdr->hdr_frag.hdr_dst_ptr = sendreq->req_peer_match;
}
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 = sendfrag;
hdr->hdr_frag.hdr_dst_ptr = sendreq->req_peer_match;
}
if (offset == 0)
sendfrag->type = MATCH;
else
sendfrag->type = FRAG;
if (offset == 0)
sendfrag->type = MATCH;
else
sendfrag->type = FRAG;
return OMPI_SUCCESS;
return OMPI_SUCCESS;
}
@ -286,22 +265,18 @@ ompi_class_t mca_ptl_gm_recv_frag_t_class = {
static void
mca_ptl_gm_recv_frag_construct (mca_ptl_gm_recv_frag_t * frag)
{
frag->frag_hdr_cnt = 0;
frag->frag_msg_cnt = 0;
frag->frag_hdr_cnt = 0;
frag->frag_msg_cnt = 0;
}
static void
mca_ptl_gm_recv_frag_destruct (mca_ptl_gm_recv_frag_t *frag)
{
;
}
mca_ptl_gm_recv_frag_t *
mca_ptl_gm_alloc_recv_frag( struct mca_ptl_base_module_t *ptl )
{
ompi_free_list_t *flist;
ompi_list_item_t *item;
mca_ptl_gm_recv_frag_t *frag;