From 6b9a59680b27bbe789336585bd00be1fae84d9a7 Mon Sep 17 00:00:00 2001 From: Augustin Degomme Date: Wed, 5 Dec 2012 18:55:18 +0100 Subject: [PATCH 1/1] modify the way we handle MPI_ANY_SOURCE, MPI_ANY_TAG, and MPI_TRUNCATED. Fix the case where a request may live outside smpi and be reused We store the values we may change in other fields --- src/smpi/private.h | 6 +++++ src/smpi/smpi_base.c | 57 +++++++++++++++++++++++++++----------------- 2 files changed, 41 insertions(+), 22 deletions(-) diff --git a/src/smpi/private.h b/src/smpi/private.h index 2a59ec5b2d..2f0d57d221 100644 --- a/src/smpi/private.h +++ b/src/smpi/private.h @@ -58,6 +58,12 @@ typedef struct s_smpi_mpi_request { int src; int dst; int tag; + //to handle cases where we have an unknown sender + //We can't override src, tag, and size, because the request may be reused later + int real_src; + int real_tag; + int truncated; + size_t real_size; MPI_Comm comm; smx_action_t action; unsigned flags; diff --git a/src/smpi/smpi_base.c b/src/smpi/smpi_base.c index 82fade3879..a016c1dafa 100644 --- a/src/smpi/smpi_base.c +++ b/src/smpi/smpi_base.c @@ -23,8 +23,16 @@ static int match_recv(void* a, void* b, smx_action_t ignored) { xbt_assert(ref, "Cannot match recv against null reference"); xbt_assert(req, "Cannot match recv against null request"); - return (ref->src == MPI_ANY_SOURCE || req->src == ref->src) - && (ref->tag == MPI_ANY_TAG || req->tag == ref->tag); + if((ref->src == MPI_ANY_SOURCE || req->src == ref->src) + && (ref->tag == MPI_ANY_TAG || req->tag == ref->tag)){ + //we match, we can transfer some values + // FIXME : move this to the copy function ? + if(ref->src == MPI_ANY_SOURCE)ref->real_src = req->src; + if(ref->tag == MPI_ANY_TAG)ref->real_tag = req->tag; + if(ref->real_size < req->real_size) ref->truncated = 1; + else ref->truncated = 0; + return 1; + }else return 0; } static int match_send(void* a, void* b,smx_action_t ignored) { @@ -33,8 +41,16 @@ static int match_send(void* a, void* b,smx_action_t ignored) { XBT_DEBUG("Trying to match a send of src %d against %d, tag %d against %d",ref->src,req->src, ref->tag, req->tag); xbt_assert(ref, "Cannot match send against null reference"); xbt_assert(req, "Cannot match send against null request"); - return (req->src == MPI_ANY_SOURCE || req->src == ref->src) - && (req->tag == MPI_ANY_TAG || req->tag == ref->tag); + + if((req->src == MPI_ANY_SOURCE || req->src == ref->src) + && (req->tag == MPI_ANY_TAG || req->tag == ref->tag)) + { + if(req->src == MPI_ANY_SOURCE)req->real_src = ref->src; + if(req->tag == MPI_ANY_TAG)req->real_tag = ref->tag; + if(req->real_size < ref->real_size) req->truncated = 1; + else ref->truncated = 0; + return 1; + } else return 0; } static MPI_Request build_request(void *buf, int count, @@ -156,9 +172,9 @@ void smpi_mpi_start(MPI_Request request) mailbox = smpi_process_mailbox_small(); else mailbox = smpi_process_mailbox(); - - // FIXME: SIMIX does not yet support non-contiguous datatypes - request->action = simcall_comm_irecv(mailbox, request->buf, &request->size, &match_recv, request); + // we make a copy here, as the size is modified by simix, and we may reuse the request in another receive later + request->real_size=request->size; + request->action = simcall_comm_irecv(mailbox, request->buf, &request->real_size, &match_recv, request); if (request->action)request->action->comm.refcount++; } else { @@ -186,10 +202,12 @@ void smpi_mpi_start(MPI_Request request) } XBT_DEBUG("Send request %p is detached; buf %p copied into %p",request,oldbuf,request->buf); } + // we make a copy here, as the size is modified by simix, and we may reuse the request in another receive later + request->real_size=request->size; request->action = simcall_comm_isend(mailbox, request->size, -1.0, - request->buf, request->size, + request->buf, request->real_size, &match_send, &smpi_mpi_request_free_voidp, // how to free the userdata if a detached send fails request, @@ -311,33 +329,29 @@ int smpi_mpi_get_count(MPI_Status * status, MPI_Datatype datatype) static void finish_wait(MPI_Request * request, MPI_Status * status) { MPI_Request req = *request; - // if we have a sender, we should use its data, and not the data from the receive - //FIXME : may fail if req->action has already been freed, the pointer being invalid - if((req->action)&& - (req->src==MPI_ANY_SOURCE || req->tag== MPI_ANY_TAG)) - //req = (MPI_Request)SIMIX_comm_get_src_data((*request)->action); if(status != MPI_STATUS_IGNORE) { - status->MPI_SOURCE = req->src; - status->MPI_TAG = req->tag; - //if((*request)->action && ((MPI_Request)SIMIX_comm_get_src_data((*request)->action))->size == (*request)->size) - status->MPI_ERROR = MPI_SUCCESS; - //else status->MPI_ERROR = MPI_ERR_TRUNCATE; + status->MPI_SOURCE = req->src == MPI_ANY_SOURCE ? req->real_src : req->src; + status->MPI_TAG = req->tag == MPI_ANY_TAG ? req->real_tag : req->tag; + if(req->truncated) + status->MPI_ERROR = MPI_ERR_TRUNCATE; + else status->MPI_ERROR = MPI_SUCCESS ; // this handles the case were size in receive differs from size in send // FIXME: really this should just contain the count of receive-type blocks, // right? - status->count = req->size; + status->count = req->real_size; } req = *request; print_request("Finishing", req); MPI_Datatype datatype = req->old_type; + if(datatype->has_subtype == 1){ // This part handles the problem of non-contignous memory // the unserialization at the reception s_smpi_subtype_t *subtype = datatype->substruct; if(req->flags & RECV) { - subtype->unserialize(req->buf, req->old_buf, req->size/smpi_datatype_size(datatype) , datatype->substruct); + subtype->unserialize(req->buf, req->old_buf, req->real_size/smpi_datatype_size(datatype) , datatype->substruct); } if(req->detached == 0) free(req->buf); } @@ -365,7 +379,6 @@ static void finish_wait(MPI_Request * request, MPI_Status * status) if(req->action){ //if we want to free our request, we have to invalidate it at the other end of the comm - if(req->flags & SEND){ req->action->comm.src_data=MPI_REQUEST_NULL; }else{ @@ -507,7 +520,7 @@ void smpi_mpi_iprobe(int source, int tag, MPI_Comm comm, int* flag, MPI_Status* status->MPI_SOURCE = req->src; status->MPI_TAG = req->tag; status->MPI_ERROR = MPI_SUCCESS; - status->count = req->size; + status->count = req->real_size; } } else *flag = 0; -- 2.20.1