X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/7286db70052377cc68be20134867bf68aa2e4a6a..fbcf6ab31cae1988be858f9f894dafe529c575d7:/src/smpi/mpi/smpi_request.cpp diff --git a/src/smpi/mpi/smpi_request.cpp b/src/smpi/mpi/smpi_request.cpp index 694a2b18d9..f0a08cc644 100644 --- a/src/smpi/mpi/smpi_request.cpp +++ b/src/smpi/mpi/smpi_request.cpp @@ -36,14 +36,14 @@ extern void (*smpi_comm_copy_data_callback)(simgrid::kernel::activity::CommImpl* namespace simgrid{ namespace smpi{ -Request::Request(void* buf, int count, MPI_Datatype datatype, int src, int dst, int tag, MPI_Comm comm, unsigned flags) - : buf_(buf), old_type_(datatype), src_(src), dst_(dst), tag_(tag), comm_(comm), flags_(flags) +Request::Request(const void* buf, int count, MPI_Datatype datatype, int src, int dst, int tag, MPI_Comm comm, unsigned flags, MPI_Op op) + : buf_(const_cast(buf)), old_type_(datatype), src_(src), dst_(dst), tag_(tag), comm_(comm), flags_(flags), op_(op) { void *old_buf = nullptr; // FIXME Handle the case of a partial shared malloc. if ((((flags & MPI_REQ_RECV) != 0) && ((flags & MPI_REQ_ACCUMULATE) != 0)) || (datatype->flags() & DT_FLAG_DERIVED)) { // This part handles the problem of non-contiguous memory - old_buf = buf; + old_buf = const_cast(buf); if (count==0){ buf_ = nullptr; }else { @@ -58,19 +58,23 @@ Request::Request(void* buf, int count, MPI_Datatype datatype, int src, int dst, size_ = datatype->size() * count; datatype->ref(); comm_->ref(); + if(op != MPI_REPLACE && op != MPI_OP_NULL) + op_->ref(); action_ = nullptr; - detached_ = 0; + detached_ = false; detached_sender_ = nullptr; real_src_ = 0; - truncated_ = 0; + truncated_ = false; real_size_ = 0; real_tag_ = 0; if (flags & MPI_REQ_PERSISTENT) refcount_ = 1; else refcount_ = 0; - op_ = MPI_REPLACE; cancelled_ = 0; + generalized_funcs=nullptr; + nbc_requests_=nullptr; + nbc_requests_size_=0; } void Request::ref(){ @@ -88,10 +92,14 @@ void Request::unref(MPI_Request* request) if((*request)->refcount_==0){ if ((*request)->flags_ & MPI_REQ_GENERALIZED){ ((*request)->generalized_funcs)->free_fn(((*request)->generalized_funcs)->extra_state); + delete (*request)->generalized_funcs; }else{ Comm::unref((*request)->comm_); Datatype::unref((*request)->old_type_); } + if ((*request)->op_!=MPI_REPLACE && (*request)->op_!=MPI_OP_NULL) + Op::unref(&(*request)->op_); + (*request)->print_request("Destroying"); delete *request; *request = MPI_REQUEST_NULL; @@ -111,7 +119,7 @@ int Request::match_recv(void* a, void* b, simgrid::kernel::activity::CommImpl*) xbt_assert(ref, "Cannot match recv against null reference"); xbt_assert(req, "Cannot match recv against null request"); - if((ref->src_ == MPI_ANY_SOURCE || req->src_ == ref->src_) + if(((ref->src_ == MPI_ANY_SOURCE && (ref->comm_->group()->rank(req->src_) != MPI_UNDEFINED)) || req->src_ == ref->src_) && ((ref->tag_ == MPI_ANY_TAG && req->tag_ >=0) || req->tag_ == ref->tag_)){ //we match, we can transfer some values if(ref->src_ == MPI_ANY_SOURCE) @@ -119,8 +127,8 @@ int Request::match_recv(void* a, void* b, simgrid::kernel::activity::CommImpl*) if(ref->tag_ == MPI_ANY_TAG) ref->real_tag_ = req->tag_; if(ref->real_size_ < req->real_size_) - ref->truncated_ = 1; - if(req->detached_==1) + ref->truncated_ = true; + if (req->detached_) ref->detached_sender_=req; //tie the sender to the receiver, as it is detached and has to be freed in the receiver if(req->cancelled_==0) req->cancelled_=-1;//mark as uncancellable @@ -137,15 +145,15 @@ int Request::match_send(void* a, void* b, simgrid::kernel::activity::CommImpl*) xbt_assert(ref, "Cannot match send against null reference"); xbt_assert(req, "Cannot match send against null request"); - if((req->src_ == MPI_ANY_SOURCE || req->src_ == ref->src_) + if(((req->src_ == MPI_ANY_SOURCE && (req->comm_->group()->rank(ref->src_) != MPI_UNDEFINED)) || req->src_ == ref->src_) && ((req->tag_ == MPI_ANY_TAG && ref->tag_ >=0)|| 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; - if(ref->detached_==1) + req->truncated_ = true; + if (ref->detached_) req->detached_sender_=ref; //tie the sender to the receiver, as it is detached and has to be freed in the receiver if(req->cancelled_==0) req->cancelled_=-1;//mark as uncancellable @@ -163,7 +171,7 @@ void Request::print_request(const char *message) /* factories, to hide the internal flags from the caller */ -MPI_Request Request::send_init(void *buf, int count, MPI_Datatype datatype, int dst, int tag, MPI_Comm comm) +MPI_Request Request::send_init(const void *buf, int count, MPI_Datatype datatype, int dst, int tag, MPI_Comm comm) { return new Request(buf == MPI_BOTTOM ? nullptr : buf, count, datatype, simgrid::s4u::this_actor::get_pid(), @@ -171,14 +179,14 @@ MPI_Request Request::send_init(void *buf, int count, MPI_Datatype datatype, int MPI_REQ_PERSISTENT | MPI_REQ_SEND | MPI_REQ_PREPARED); } -MPI_Request Request::ssend_init(void *buf, int count, MPI_Datatype datatype, int dst, int tag, MPI_Comm comm) +MPI_Request Request::ssend_init(const void *buf, int count, MPI_Datatype datatype, int dst, int tag, MPI_Comm comm) { return new Request(buf == MPI_BOTTOM ? nullptr : buf, count, datatype, simgrid::s4u::this_actor::get_pid(), comm->group()->actor(dst)->get_pid(), tag, comm, MPI_REQ_PERSISTENT | MPI_REQ_SSEND | MPI_REQ_SEND | MPI_REQ_PREPARED); } -MPI_Request Request::isend_init(void *buf, int count, MPI_Datatype datatype, int dst, int tag, MPI_Comm comm) +MPI_Request Request::isend_init(const void *buf, int count, MPI_Datatype datatype, int dst, int tag, MPI_Comm comm) { return new Request(buf == MPI_BOTTOM ? nullptr : buf, count, datatype, simgrid::s4u::this_actor::get_pid(), comm->group()->actor(dst)->get_pid(), tag, comm, @@ -186,7 +194,7 @@ MPI_Request Request::isend_init(void *buf, int count, MPI_Datatype datatype, int } -MPI_Request Request::rma_send_init(void *buf, int count, MPI_Datatype datatype, int src, int dst, int tag, MPI_Comm comm, +MPI_Request Request::rma_send_init(const void *buf, int count, MPI_Datatype datatype, int src, int dst, int tag, MPI_Comm comm, MPI_Op op) { MPI_Request request = nullptr; /* MC needs the comm to be set to nullptr during the call */ @@ -198,8 +206,7 @@ MPI_Request Request::rma_send_init(void *buf, int count, MPI_Datatype datatype, request = new Request(buf == MPI_BOTTOM ? nullptr : buf, count, datatype, comm->group()->actor(src)->get_pid(), comm->group()->actor(dst)->get_pid(), tag, comm, MPI_REQ_RMA | MPI_REQ_NON_PERSISTENT | MPI_REQ_ISEND | MPI_REQ_SEND | MPI_REQ_PREPARED | - MPI_REQ_ACCUMULATE); - request->op_ = op; + MPI_REQ_ACCUMULATE, op); } return request; } @@ -223,8 +230,7 @@ MPI_Request Request::rma_recv_init(void *buf, int count, MPI_Datatype datatype, }else{ request = new Request(buf == MPI_BOTTOM ? nullptr : buf, count, datatype, comm->group()->actor(src)->get_pid(), comm->group()->actor(dst)->get_pid(), tag, comm, - MPI_REQ_RMA | MPI_REQ_NON_PERSISTENT | MPI_REQ_RECV | MPI_REQ_PREPARED | MPI_REQ_ACCUMULATE); - request->op_ = op; + MPI_REQ_RMA | MPI_REQ_NON_PERSISTENT | MPI_REQ_RECV | MPI_REQ_PREPARED | MPI_REQ_ACCUMULATE, op); } return request; } @@ -237,7 +243,7 @@ MPI_Request Request::irecv_init(void *buf, int count, MPI_Datatype datatype, int MPI_REQ_PERSISTENT | MPI_REQ_RECV | MPI_REQ_PREPARED); } -MPI_Request Request::isend(void *buf, int count, MPI_Datatype datatype, int dst, int tag, MPI_Comm comm) +MPI_Request Request::isend(const void *buf, int count, MPI_Datatype datatype, int dst, int tag, MPI_Comm comm) { MPI_Request request = nullptr; /* MC needs the comm to be set to nullptr during the call */ request = new Request(buf == MPI_BOTTOM ? nullptr : buf, count, datatype, simgrid::s4u::this_actor::get_pid(), @@ -247,7 +253,7 @@ MPI_Request Request::isend(void *buf, int count, MPI_Datatype datatype, int dst, return request; } -MPI_Request Request::issend(void *buf, int count, MPI_Datatype datatype, int dst, int tag, MPI_Comm comm) +MPI_Request Request::issend(const void *buf, int count, MPI_Datatype datatype, int dst, int tag, MPI_Comm comm) { MPI_Request request = nullptr; /* MC needs the comm to be set to nullptr during the call */ request = new Request(buf == MPI_BOTTOM ? nullptr : buf, count, datatype, simgrid::s4u::this_actor::get_pid(), @@ -276,7 +282,7 @@ void Request::recv(void *buf, int count, MPI_Datatype datatype, int src, int tag request = nullptr; } -void Request::send(void *buf, int count, MPI_Datatype datatype, int dst, int tag, MPI_Comm comm) +void Request::send(const void *buf, int count, MPI_Datatype datatype, int dst, int tag, MPI_Comm comm) { MPI_Request request = nullptr; /* MC needs the comm to be set to nullptr during the call */ request = new Request(buf == MPI_BOTTOM ? nullptr : buf, count, datatype, simgrid::s4u::this_actor::get_pid(), @@ -287,7 +293,7 @@ void Request::send(void *buf, int count, MPI_Datatype datatype, int dst, int tag request = nullptr; } -void Request::ssend(void *buf, int count, MPI_Datatype datatype, int dst, int tag, MPI_Comm comm) +void Request::ssend(const void *buf, int count, MPI_Datatype datatype, int dst, int tag, MPI_Comm comm) { MPI_Request request = nullptr; /* MC needs the comm to be set to nullptr during the call */ request = new Request(buf == MPI_BOTTOM ? nullptr : buf, count, datatype, simgrid::s4u::this_actor::get_pid(), @@ -299,7 +305,7 @@ void Request::ssend(void *buf, int count, MPI_Datatype datatype, int dst, int ta request = nullptr; } -void Request::sendrecv(void *sendbuf, int sendcount, MPI_Datatype sendtype,int dst, int sendtag, +void Request::sendrecv(const void *sendbuf, int sendcount, MPI_Datatype sendtype,int dst, int sendtag, void *recvbuf, int recvcount, MPI_Datatype recvtype, int src, int recvtag, MPI_Comm comm, MPI_Status * status) { @@ -404,7 +410,7 @@ void Request::start() ((flags_ & MPI_REQ_RMA) != 0 || static_cast(size_) < simgrid::config::get_value("smpi/send-is-detached-thresh"))) { void *oldbuf = nullptr; - detached_ = 1; + detached_ = true; XBT_DEBUG("Send request %p is detached", this); this->ref(); if (not(old_type_->flags() & DT_FLAG_DERIVED)) { @@ -425,7 +431,7 @@ void Request::start() //if we are giving back the control to the user without waiting for completion, we have to inject timings double sleeptime = 0.0; - if (detached_ != 0 || ((flags_ & (MPI_REQ_ISEND | MPI_REQ_SSEND)) != 0)) { // issend should be treated as isend + if (detached_ || ((flags_ & (MPI_REQ_ISEND | MPI_REQ_SSEND)) != 0)) { // issend should be treated as isend // isend and send timings may be different sleeptime = ((flags_ & MPI_REQ_ISEND) != 0) ? simgrid::s4u::Actor::self()->get_host()->extension()->oisend(size_) @@ -485,8 +491,8 @@ void Request::start() /* FIXME: detached sends are not traceable (action_ == nullptr) */ if (action_ != nullptr) { - std::string category = smpi_process()->get_tracing_category(); - simgrid::simix::simcall([this, category] { this->action_->set_category(category); }); + boost::static_pointer_cast(action_)->set_tracing_category( + smpi_process()->get_tracing_category()); } if (async_small_thresh != 0 || ((flags_ & MPI_REQ_RMA) != 0)) @@ -520,17 +526,29 @@ int Request::test(MPI_Request * request, MPI_Status * status, int* flag) { // multiplier to the sleeptime, to increase speed of execution, each failed test will increase it static int nsleeps = 1; int ret = MPI_SUCCESS; + + // Are we testing a request meant for non blocking collectives ? + // If so, test all the subrequests. + if ((*request)->nbc_requests_size_>0){ + ret = testall((*request)->nbc_requests_size_, (*request)->nbc_requests_, flag, MPI_STATUSES_IGNORE); + if(*flag){ + delete[] (*request)->nbc_requests_; + (*request)->nbc_requests_size_=0; + unref(request); + } + return ret; + } + if(smpi_test_sleep > 0) simcall_process_sleep(nsleeps*smpi_test_sleep); - MPI_Status* mystatus; Status::empty(status); *flag = 1; if (((*request)->flags_ & MPI_REQ_PREPARED) == 0) { if ((*request)->action_ != nullptr){ try{ *flag = simcall_comm_test((*request)->action_); - }catch (xbt_ex& e) { + } catch (const xbt_ex&) { *flag = 0; return ret; } @@ -542,6 +560,7 @@ int Request::test(MPI_Request * request, MPI_Status * status, int* flag) { if (*flag) { finish_wait(request,status); if (*request != MPI_REQUEST_NULL && ((*request)->flags_ & MPI_REQ_GENERALIZED)){ + MPI_Status* mystatus; if(status==MPI_STATUS_IGNORE){ mystatus=new MPI_Status(); Status::empty(mystatus); @@ -604,7 +623,6 @@ int Request::testany(int count, MPI_Request requests[], int *index, int* flag, M int i; *flag = 0; int ret = MPI_SUCCESS; - MPI_Status* mystatus; *index = MPI_UNDEFINED; std::vector map; /** Maps all matching comms back to their location in requests **/ @@ -621,7 +639,8 @@ int Request::testany(int count, MPI_Request requests[], int *index, int* flag, M simcall_process_sleep(nsleeps*smpi_test_sleep); try{ i = simcall_comm_testany(comms.data(), comms.size()); // The i-th element in comms matches! - }catch (xbt_ex& e) { + } catch (const xbt_ex&) { + XBT_DEBUG("Exception in testany"); return 0; } @@ -634,6 +653,7 @@ int Request::testany(int count, MPI_Request requests[], int *index, int* flag, M } else { finish_wait(&requests[*index],status); if (requests[*index] != MPI_REQUEST_NULL && (requests[*index]->flags_ & MPI_REQ_GENERALIZED)){ + MPI_Status* mystatus; if(status==MPI_STATUS_IGNORE){ mystatus=new MPI_Status(); Status::empty(mystatus); @@ -647,6 +667,7 @@ int Request::testany(int count, MPI_Request requests[], int *index, int* flag, M if (requests[*index] != MPI_REQUEST_NULL && (requests[*index]->flags_ & MPI_REQ_NON_PERSISTENT)) requests[*index] = MPI_REQUEST_NULL; + XBT_DEBUG("Testany - returning with index %d", *index); *flag=1; } nsleeps = 1; @@ -654,8 +675,10 @@ int Request::testany(int count, MPI_Request requests[], int *index, int* flag, M nsleeps++; } } else { + XBT_DEBUG("Testany on inactive handles, returning flag=1 but empty status"); //all requests are null or inactive, return true *flag = 1; + *index = MPI_UNDEFINED; Status::empty(status); } @@ -666,7 +689,8 @@ int Request::testall(int count, MPI_Request requests[], int* outflag, MPI_Status { MPI_Status stat; MPI_Status *pstat = status == MPI_STATUSES_IGNORE ? MPI_STATUS_IGNORE : &stat; - int flag, error=0; + int flag; + int error = 0; int ret=MPI_SUCCESS; *outflag = 1; for(int i=0; idetached_ != 0) && ((req->flags_ & MPI_REQ_SEND) != 0)) - && ((req->flags_ & MPI_REQ_PREPARED) == 0) - && ((req->flags_ & MPI_REQ_GENERALIZED) == 0)) { + if (not(req->detached_ && ((req->flags_ & MPI_REQ_SEND) != 0)) && ((req->flags_ & MPI_REQ_PREPARED) == 0) && + ((req->flags_ & MPI_REQ_GENERALIZED) == 0)) { if(status != MPI_STATUS_IGNORE) { int src = req->src_ == MPI_ANY_SOURCE ? req->real_src_ : req->src_; status->MPI_SOURCE = req->comm_->group()->rank(src); status->MPI_TAG = req->tag_ == MPI_ANY_TAG ? req->real_tag_ : req->tag_; - status->MPI_ERROR = req->truncated_ != 0 ? MPI_ERR_TRUNCATE : MPI_SUCCESS; + status->MPI_ERROR = req->truncated_ ? MPI_ERR_TRUNCATE : MPI_SUCCESS; // this handles the case were size in receive differs from size in send status->count = req->real_size_; } @@ -844,6 +868,33 @@ void Request::finish_wait(MPI_Request* request, MPI_Status * status) int Request::wait(MPI_Request * request, MPI_Status * status) { int ret=MPI_SUCCESS; + // Are we waiting on a request meant for non blocking collectives ? + // If so, wait for all the subrequests. + if ((*request)->nbc_requests_size_>0){ + ret = waitall((*request)->nbc_requests_size_, (*request)->nbc_requests_, MPI_STATUSES_IGNORE); + for (int i = 0; i < (*request)->nbc_requests_size_; i++) { + if((*request)->buf_!=nullptr && (*request)->nbc_requests_[i]!=MPI_REQUEST_NULL){//reduce case + void * buf=(*request)->nbc_requests_[i]->buf_; + if((*request)->old_type_->flags() & DT_FLAG_DERIVED) + buf=(*request)->nbc_requests_[i]->old_buf_; + if((*request)->nbc_requests_[i]->flags_ & MPI_REQ_RECV ){ + if((*request)->op_!=MPI_OP_NULL){ + int count=(*request)->size_/ (*request)->old_type_->size(); + (*request)->op_->apply(buf, (*request)->buf_, &count, (*request)->old_type_); + } + smpi_free_tmp_buffer(static_cast(buf)); + } + } + if((*request)->nbc_requests_[i]!=MPI_REQUEST_NULL) + Request::unref(&((*request)->nbc_requests_[i])); + } + delete[] (*request)->nbc_requests_; + (*request)->nbc_requests_size_=0; + unref(request); + (*request)=MPI_REQUEST_NULL; + return ret; + } + (*request)->print_request("Waiting"); if ((*request)->flags_ & MPI_REQ_PREPARED) { Status::empty(status); @@ -854,7 +905,7 @@ int Request::wait(MPI_Request * request, MPI_Status * status) try{ // this is not a detached send simcall_comm_wait((*request)->action_, -1.0); - }catch (xbt_ex& e) { + } catch (const xbt_ex&) { XBT_VERB("Request cancelled"); } } @@ -917,8 +968,8 @@ int Request::waitany(int count, MPI_Request requests[], MPI_Status * status) try{ // this is not a detached send i = simcall_comm_waitany(comms.data(), comms.size(), -1); - }catch (xbt_ex& e) { - XBT_INFO("request %d cancelled ",i); + } catch (const xbt_ex&) { + XBT_INFO("request %d cancelled ", i); return i; } @@ -1015,7 +1066,7 @@ int Request::waitsome(int incount, MPI_Request requests[], int *indices, MPI_Sta indices[count] = index; count++; for (int i = 0; i < incount; i++) { - if((requests[i] != MPI_REQUEST_NULL)) { + if (requests[i] != MPI_REQUEST_NULL) { test(&requests[i], pstat,&flag); if (flag==1){ indices[count] = i; @@ -1063,7 +1114,7 @@ int Request::get_status(MPI_Request req, int* flag, MPI_Status * status){ if(req != MPI_REQUEST_NULL && req->action_ != nullptr) { req->iprobe(req->src_, req->tag_, req->comm_, flag, status); - if(flag) + if(*flag) return MPI_SUCCESS; } if (req != MPI_REQUEST_NULL && @@ -1074,7 +1125,8 @@ int Request::get_status(MPI_Request req, int* flag, MPI_Status * status){ } *flag=1; - if(status != MPI_STATUS_IGNORE) { + if(req != MPI_REQUEST_NULL && + status != MPI_STATUS_IGNORE) { int src = req->src_ == MPI_ANY_SOURCE ? req->real_src_ : req->src_; status->MPI_SOURCE = req->comm_->group()->rank(src); status->MPI_TAG = req->tag_ == MPI_ANY_TAG ? req->real_tag_ : req->tag_; @@ -1090,7 +1142,7 @@ int Request::grequest_start( MPI_Grequest_query_function *query_fn, MPI_Grequest (*request)->flags_ |= MPI_REQ_GENERALIZED; (*request)->flags_ |= MPI_REQ_PERSISTENT; (*request)->refcount_ = 1; - ((*request)->generalized_funcs)=xbt_new0(s_smpi_mpi_generalized_request_funcs_t ,1); + ((*request)->generalized_funcs) = new s_smpi_mpi_generalized_request_funcs_t; ((*request)->generalized_funcs)->query_fn=query_fn; ((*request)->generalized_funcs)->free_fn=free_fn; ((*request)->generalized_funcs)->cancel_fn=cancel_fn; @@ -1110,5 +1162,23 @@ int Request::grequest_complete( MPI_Request request){ return MPI_SUCCESS; } +void Request::set_nbc_requests(MPI_Request* reqs, int size){ + nbc_requests_size_ = size; + if (size > 0) { + nbc_requests_ = reqs; + } else { + delete[] reqs; + nbc_requests_ = nullptr; + } +} + +int Request::get_nbc_requests_size(){ + return nbc_requests_size_; +} + +MPI_Request* Request::get_nbc_requests(){ + return nbc_requests_; +} + } }