X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/c864f7396a94658545769fb9c28e9ff7cef02530..9cfb1e3cb58d1b202719b8380fbca27f7dcef9c4:/src/smpi/mpi/smpi_request.cpp diff --git a/src/smpi/mpi/smpi_request.cpp b/src/smpi/mpi/smpi_request.cpp index d99290b80e..390fed1ce7 100644 --- a/src/smpi/mpi/smpi_request.cpp +++ b/src/smpi/mpi/smpi_request.cpp @@ -1,4 +1,4 @@ -/* Copyright (c) 2007-2019. The SimGrid Team. All rights reserved. */ +/* Copyright (c) 2007-2020. The SimGrid Team. All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ @@ -18,6 +18,7 @@ #include "src/smpi/include/smpi_actor.hpp" #include +#include XBT_LOG_NEW_DEFAULT_SUBCATEGORY(smpi_request, smpi, "Logging specific to SMPI (request)"); @@ -33,26 +34,18 @@ extern void (*smpi_comm_copy_data_callback)(simgrid::kernel::activity::CommImpl* namespace simgrid{ namespace smpi{ -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) +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) + , size_(datatype->size() * count) + , 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 = const_cast(buf); - if (count==0){ - buf_ = nullptr; - }else { - buf_ = xbt_malloc(count*datatype->size()); - if ((datatype->flags() & DT_FLAG_DERIVED) && ((flags & MPI_REQ_SEND) != 0)) { - datatype->serialize(old_buf, buf_, count); - } - } - } - // This part handles the problem of non-contiguous memory (for the unserialization at the reception) - old_buf_ = old_buf; - size_ = datatype->size() * count; datatype->ref(); comm_->ref(); if(op != MPI_REPLACE && op != MPI_OP_NULL) @@ -69,9 +62,9 @@ Request::Request(const void* buf, int count, MPI_Datatype datatype, int src, int else refcount_ = 0; cancelled_ = 0; - generalized_funcs=nullptr; nbc_requests_=nullptr; nbc_requests_size_=0; + init_buffer(count); } void Request::ref(){ @@ -89,7 +82,6 @@ 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_); @@ -108,71 +100,79 @@ void Request::unref(MPI_Request* request) } } -int Request::match_recv(void* a, void* b, simgrid::kernel::activity::CommImpl*) +bool Request::match_common(MPI_Request req, MPI_Request sender, MPI_Request receiver) { - MPI_Request ref = static_cast(a); - MPI_Request req = static_cast(b); - XBT_DEBUG("Trying to match a recv of src %d against %d, tag %d against %d, id %d against %d",ref->src_,req->src_, ref->tag_, req->tag_,ref->comm_->id(),req->comm_->id()); - - xbt_assert(ref, "Cannot match recv against null reference"); - xbt_assert(req, "Cannot match recv against null request"); - if((ref->comm_->id()==MPI_UNDEFINED || req->comm_->id() == MPI_UNDEFINED || (ref->comm_->id()==req->comm_->id())) - && ((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) - 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_ = 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) + xbt_assert(sender, "Cannot match against null sender"); + xbt_assert(receiver, "Cannot match against null receiver"); + XBT_DEBUG("Trying to match %s of sender src %d against %d, tag %d against %d, id %d against %d", + (req == receiver ? "send" : "recv"), sender->src_, receiver->src_, sender->tag_, receiver->tag_, + sender->comm_->id(), receiver->comm_->id()); + + if ((receiver->comm_->id() == MPI_UNDEFINED || sender->comm_->id() == MPI_UNDEFINED || + receiver->comm_->id() == sender->comm_->id()) && + ((receiver->src_ == MPI_ANY_SOURCE && (receiver->comm_->group()->rank(sender->src_) != MPI_UNDEFINED)) || + receiver->src_ == sender->src_) && + ((receiver->tag_ == MPI_ANY_TAG && sender->tag_ >= 0) || receiver->tag_ == sender->tag_)) { + // we match, we can transfer some values + if (receiver->src_ == MPI_ANY_SOURCE) + receiver->real_src_ = sender->src_; + if (receiver->tag_ == MPI_ANY_TAG) + receiver->real_tag_ = sender->tag_; + if (receiver->real_size_ < sender->real_size_) + receiver->truncated_ = true; + if (sender->detached_) + receiver->detached_sender_ = sender; // 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 uncancelable XBT_DEBUG("match succeeded"); - return 1; - }else return 0; + return true; + } + return false; +} + +void Request::init_buffer(int count){ + void *old_buf = nullptr; +// FIXME Handle the case of a partial shared malloc. + // This part handles the problem of non-contiguous memory (for the unserialization at the reception) + if ((((flags_ & MPI_REQ_RECV) != 0) && ((flags_ & MPI_REQ_ACCUMULATE) != 0)) || (old_type_->flags() & DT_FLAG_DERIVED)) { + // This part handles the problem of non-contiguous memory + old_buf = buf_; + if (count==0){ + buf_ = nullptr; + }else { + buf_ = xbt_malloc(count*old_type_->size()); + if ((old_type_->flags() & DT_FLAG_DERIVED) && ((flags_ & MPI_REQ_SEND) != 0)) { + old_type_->serialize(old_buf, buf_, count); + } + } + } + old_buf_ = old_buf; } -int Request::match_send(void* a, void* b, simgrid::kernel::activity::CommImpl*) +bool Request::match_recv(void* a, void* b, simgrid::kernel::activity::CommImpl*) { - MPI_Request ref = static_cast(a); - MPI_Request req = static_cast(b); - XBT_DEBUG("Trying to match a send of src %d against %d, tag %d against %d, id %d against %d",ref->src_,req->src_, ref->tag_, req->tag_,ref->comm_->id(),req->comm_->id()); - xbt_assert(ref, "Cannot match send against null reference"); - xbt_assert(req, "Cannot match send against null request"); - - if((ref->comm_->id()==MPI_UNDEFINED || req->comm_->id() == MPI_UNDEFINED || (ref->comm_->id()==req->comm_->id())) - && ((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_ = 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 uncancelable - XBT_DEBUG("match succeeded"); - return 1; - } else - return 0; + auto ref = static_cast(a); + auto req = static_cast(b); + return match_common(req, req, ref); } -void Request::print_request(const char *message) +bool Request::match_send(void* a, void* b, simgrid::kernel::activity::CommImpl*) +{ + auto ref = static_cast(a); + auto req = static_cast(b); + return match_common(req, ref, req); +} + +void Request::print_request(const char* message) const { XBT_VERB("%s request %p [buf = %p, size = %zu, src = %d, dst = %d, tag = %d, flags = %x]", message, this, buf_, size_, src_, dst_, tag_, flags_); } - /* factories, to hide the internal flags from the caller */ MPI_Request Request::bsend_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_SEND | MPI_REQ_PREPARED | MPI_REQ_BSEND); @@ -180,7 +180,6 @@ MPI_Request Request::bsend_init(const void *buf, int count, MPI_Datatype datatyp 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(), comm->group()->actor(dst)->get_pid(), tag, comm, MPI_REQ_PERSISTENT | MPI_REQ_SEND | MPI_REQ_PREPARED); @@ -337,8 +336,8 @@ void Request::sendrecv(const void *sendbuf, int sendcount, MPI_Datatype sendtype void *recvbuf, int recvcount, MPI_Datatype recvtype, int src, int recvtag, MPI_Comm comm, MPI_Status * status) { - MPI_Request requests[2]; - MPI_Status stats[2]; + std::array requests; + std::array stats; int myid = simgrid::s4u::this_actor::get_pid(); if ((comm->group()->actor(dst)->get_pid() == myid) && (comm->group()->actor(src)->get_pid() == myid)) { Datatype::copy(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype); @@ -352,8 +351,8 @@ void Request::sendrecv(const void *sendbuf, int sendcount, MPI_Datatype sendtype } requests[0] = isend_init(sendbuf, sendcount, sendtype, dst, sendtag, comm); requests[1] = irecv_init(recvbuf, recvcount, recvtype, src, recvtag, comm); - startall(2, requests); - waitall(2, requests, stats); + startall(2, requests.data()); + waitall(2, requests.data(), stats.data()); unref(&requests[0]); unref(&requests[1]); if(status != MPI_STATUS_IGNORE) { @@ -367,6 +366,11 @@ void Request::start() s4u::Mailbox* mailbox; xbt_assert(action_ == nullptr, "Cannot (re-)start unfinished communication"); + //reinitialize temporary buffer for persistent requests + if(real_size_ > 0 && flags_ & MPI_REQ_FINISHED){ + buf_ = old_buf_; + init_buffer(real_size_/old_type_->size()); + } flags_ &= ~MPI_REQ_PREPARED; flags_ &= ~MPI_REQ_FINISHED; this->ref(); @@ -388,7 +392,7 @@ void Request::start() mailbox = process->mailbox_small(); XBT_DEBUG("Is there a corresponding send already posted in the small mailbox %s (in case of SSEND)?", mailbox->get_cname()); - smx_activity_t action = mailbox->iprobe(0, &match_recv, static_cast(this)); + simgrid::kernel::activity::ActivityImplPtr action = mailbox->iprobe(0, &match_recv, static_cast(this)); if (action == nullptr) { mailbox = process->mailbox(); @@ -404,7 +408,7 @@ void Request::start() } else { mailbox = process->mailbox_small(); XBT_DEBUG("Is there a corresponding send already posted the small mailbox?"); - smx_activity_t action = mailbox->iprobe(0, &match_recv, static_cast(this)); + simgrid::kernel::activity::ActivityImplPtr action = mailbox->iprobe(0, &match_recv, static_cast(this)); if (action == nullptr) { XBT_DEBUG("No, nothing in the permanent receive mailbox"); @@ -424,7 +428,7 @@ void Request::start() if (smpi_cfg_async_small_thresh() != 0 || (flags_ & MPI_REQ_RMA) != 0) mut->unlock(); } else { /* the RECV flag was not set, so this is a send */ - simgrid::smpi::ActorExt* process = smpi_process_remote(simgrid::s4u::Actor::by_pid(dst_)); + const simgrid::smpi::ActorExt* process = smpi_process_remote(simgrid::s4u::Actor::by_pid(dst_)); xbt_assert(process, "Actor pid=%d is gone??", dst_); int rank = src_; if (TRACE_smpi_view_internals()) { @@ -482,7 +486,7 @@ void Request::start() } else if (((flags_ & MPI_REQ_RMA) != 0) || static_cast(size_) < smpi_cfg_async_small_thresh()) { // eager mode mailbox = process->mailbox(); XBT_DEBUG("Is there a corresponding recv already posted in the large mailbox %s?", mailbox->get_cname()); - smx_activity_t action = mailbox->iprobe(1, &match_send, static_cast(this)); + simgrid::kernel::activity::ActivityImplPtr action = mailbox->iprobe(1, &match_send, static_cast(this)); if (action == nullptr) { if ((flags_ & MPI_REQ_SSEND) == 0) { mailbox = process->mailbox_small(); @@ -508,8 +512,9 @@ void Request::start() // we make a copy here, as the size is modified by simix, and we may reuse the request in another receive later real_size_=size_; + size_t payload_size_ = size_ + 16;//MPI enveloppe size (tag+dest+communicator) action_ = simcall_comm_isend( - simgrid::s4u::Actor::by_pid(src_)->get_impl(), mailbox->get_impl(), size_, -1.0, buf, real_size_, &match_send, + simgrid::s4u::Actor::by_pid(src_)->get_impl(), mailbox->get_impl(), payload_size_, -1.0, buf, real_size_, &match_send, &xbt_free_f, // how to free the userdata if a detached send fails process->replaying() ? &smpi_comm_null_copy_buffer_callback : smpi_comm_copy_data_callback, this, // detach if msg size < eager/rdv switch limit @@ -546,11 +551,13 @@ void Request::cancel() } int Request::test(MPI_Request * request, MPI_Status * status, int* flag) { - //assume that request is not MPI_REQUEST_NULL (filtered in PMPI_Test or testall before) + // assume that *request is not MPI_REQUEST_NULL (filtered in PMPI_Test or testall before) // to avoid deadlocks if used as a break condition, such as // while (MPI_Test(request, flag, status) && flag) dostuff... // because the time will not normally advance when only calls to MPI_Test are made -> deadlock // multiplier to the sleeptime, to increase speed of execution, each failed test will increase it + xbt_assert(*request != MPI_REQUEST_NULL); + static int nsleeps = 1; int ret = MPI_SUCCESS; @@ -571,32 +578,29 @@ int Request::test(MPI_Request * request, MPI_Status * status, int* flag) { Status::empty(status); *flag = 1; - if (((*request)->flags_ & MPI_REQ_PREPARED) == 0) { + if (((*request)->flags_ & (MPI_REQ_PREPARED | MPI_REQ_FINISHED)) == 0) { if ((*request)->action_ != nullptr && (*request)->cancelled_ != 1){ try{ - *flag = simcall_comm_test((*request)->action_); + *flag = simcall_comm_test((*request)->action_.get()); } catch (const Exception&) { *flag = 0; return ret; } } - if (*request != MPI_REQUEST_NULL && - ((*request)->flags_ & MPI_REQ_GENERALIZED) - && !((*request)->flags_ & MPI_REQ_COMPLETE)) + if (((*request)->flags_ & MPI_REQ_GENERALIZED) && !((*request)->flags_ & MPI_REQ_COMPLETE)) *flag=0; if (*flag) { - finish_wait(request,status); + finish_wait(request, status); // may invalidate *request if (*request != MPI_REQUEST_NULL && ((*request)->flags_ & MPI_REQ_GENERALIZED)){ + MPI_Status tmp_status; MPI_Status* mystatus; - if(status==MPI_STATUS_IGNORE){ - mystatus=new MPI_Status(); + if (status == MPI_STATUS_IGNORE) { + mystatus = &tmp_status; Status::empty(mystatus); - }else{ - mystatus=status; + } else { + mystatus = status; } ret = ((*request)->generalized_funcs)->query_fn(((*request)->generalized_funcs)->extra_state, mystatus); - if(status==MPI_STATUS_IGNORE) - delete mystatus; } nsleeps=1;//reset the number of sleeps we will do next time if (*request != MPI_REQUEST_NULL && ((*request)->flags_ & MPI_REQ_PERSISTENT) == 0) @@ -679,16 +683,15 @@ 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 tmp_status; MPI_Status* mystatus; - if(status==MPI_STATUS_IGNORE){ - mystatus=new MPI_Status(); + if (status == MPI_STATUS_IGNORE) { + mystatus = &tmp_status; Status::empty(mystatus); - }else{ - mystatus=status; + } else { + mystatus = status; } ret=(requests[*index]->generalized_funcs)->query_fn((requests[*index]->generalized_funcs)->extra_state, mystatus); - if(status==MPI_STATUS_IGNORE) - delete mystatus; } if (requests[*index] != MPI_REQUEST_NULL && (requests[*index]->flags_ & MPI_REQ_NON_PERSISTENT)) @@ -760,9 +763,9 @@ void Request::iprobe(int source, int tag, MPI_Comm comm, int* flag, MPI_Status* static int nsleeps = 1; double speed = s4u::this_actor::get_host()->get_speed(); double maxrate = smpi_cfg_iprobe_cpu_usage(); - MPI_Request request = new Request(nullptr, 0, MPI_CHAR, - source == MPI_ANY_SOURCE ? MPI_ANY_SOURCE : comm->group()->actor(source)->get_pid(), - simgrid::s4u::this_actor::get_pid(), tag, comm, MPI_REQ_PERSISTENT | MPI_REQ_RECV); + auto request = new Request(nullptr, 0, MPI_CHAR, + source == MPI_ANY_SOURCE ? MPI_ANY_SOURCE : comm->group()->actor(source)->get_pid(), + simgrid::s4u::this_actor::get_pid(), tag, comm, MPI_REQ_PERSISTENT | MPI_REQ_RECV); if (smpi_iprobe_sleep > 0) { /** Compute the number of flops we will sleep **/ s4u::this_actor::exec_init(/*nsleeps: See comment above */ nsleeps * @@ -796,7 +799,7 @@ void Request::iprobe(int source, int tag, MPI_Comm comm, int* flag, MPI_Status* if (request->action_ != nullptr){ kernel::activity::CommImplPtr sync_comm = boost::static_pointer_cast(request->action_); - MPI_Request req = static_cast(sync_comm->src_data_); + const Request* req = static_cast(sync_comm->src_data_); *flag = 1; if (status != MPI_STATUS_IGNORE && (req->flags_ & MPI_REQ_PREPARED) == 0) { status->MPI_SOURCE = comm->group()->rank(req->src_); @@ -846,7 +849,6 @@ void Request::finish_wait(MPI_Request* request, MPI_Status * status) // FIXME Handle the case of a partial shared malloc. if (((req->flags_ & MPI_REQ_ACCUMULATE) != 0) || (datatype->flags() & DT_FLAG_DERIVED)) { // && (not smpi_is_shared(req->old_buf_))){ - if (not smpi_process()->replaying() && smpi_cfg_privatization() != SmpiPrivStrategies::NONE && static_cast(req->old_buf_) >= smpi_data_exe_start && static_cast(req->old_buf_) < smpi_data_exe_start + smpi_data_exe_size) { @@ -859,12 +861,14 @@ void Request::finish_wait(MPI_Request* request, MPI_Status * status) if ((req->flags_ & MPI_REQ_RECV) && datatype->size() != 0) datatype->unserialize(req->buf_, req->old_buf_, req->real_size_/datatype->size() , req->op_); xbt_free(req->buf_); + req->buf_=nullptr; } else if (req->flags_ & MPI_REQ_RECV) { // apply op on contiguous buffer for accumulate if (datatype->size() != 0) { int n = req->real_size_ / datatype->size(); req->op_->apply(req->buf_, req->old_buf_, &n, datatype); } xbt_free(req->buf_); + req->buf_=nullptr; } } } @@ -893,6 +897,9 @@ void Request::finish_wait(MPI_Request* request, MPI_Status * status) int Request::wait(MPI_Request * request, MPI_Status * status) { + // assume that *request is not MPI_REQUEST_NULL (filtered in PMPI_Wait before) + xbt_assert(*request != MPI_REQUEST_NULL); + int ret=MPI_SUCCESS; // Are we waiting on a request meant for non blocking collectives ? // If so, wait for all the subrequests. @@ -922,7 +929,7 @@ int Request::wait(MPI_Request * request, MPI_Status * status) } (*request)->print_request("Waiting"); - if ((*request)->flags_ & MPI_REQ_PREPARED) { + if ((*request)->flags_ & (MPI_REQ_PREPARED | MPI_REQ_FINISHED)) { Status::empty(status); return ret; } @@ -930,31 +937,30 @@ int Request::wait(MPI_Request * request, MPI_Status * status) if ((*request)->action_ != nullptr){ try{ // this is not a detached send - simcall_comm_wait((*request)->action_, -1.0); + simcall_comm_wait((*request)->action_.get(), -1.0); } catch (const Exception&) { XBT_VERB("Request cancelled"); } } - if (*request != MPI_REQUEST_NULL && ((*request)->flags_ & MPI_REQ_GENERALIZED)){ - MPI_Status* mystatus; + if ((*request)->flags_ & MPI_REQ_GENERALIZED) { if(!((*request)->flags_ & MPI_REQ_COMPLETE)){ ((*request)->generalized_funcs)->mutex->lock(); ((*request)->generalized_funcs)->cond->wait(((*request)->generalized_funcs)->mutex); ((*request)->generalized_funcs)->mutex->unlock(); - } - if(status==MPI_STATUS_IGNORE){ - mystatus=new MPI_Status(); + } + MPI_Status tmp_status; + MPI_Status* mystatus; + if (status == MPI_STATUS_IGNORE) { + mystatus = &tmp_status; Status::empty(mystatus); - }else{ - mystatus=status; + } else { + mystatus = status; } ret = ((*request)->generalized_funcs)->query_fn(((*request)->generalized_funcs)->extra_state, mystatus); - if(status==MPI_STATUS_IGNORE) - delete mystatus; } - finish_wait(request,status); + finish_wait(request, status); // may invalidate *request if (*request != MPI_REQUEST_NULL && (((*request)->flags_ & MPI_REQ_NON_PERSISTENT) != 0)) *request = MPI_REQUEST_NULL; return ret; @@ -1019,7 +1025,7 @@ int Request::waitany(int count, MPI_Request requests[], MPI_Status * status) return index; } -static int sort_accumulates(MPI_Request a, MPI_Request b) +static int sort_accumulates(const Request* a, const Request* b) { return (a->tag() > b->tag()); } @@ -1048,8 +1054,8 @@ int Request::waitall(int count, MPI_Request requests[], MPI_Status status[]) wait(&requests[c],pstat); index = c; } else { - index = waitany(count, (MPI_Request*)requests, pstat); - + index = waitany(count, requests, pstat); + if (index == MPI_UNDEFINED) break; @@ -1083,7 +1089,7 @@ int Request::waitsome(int incount, MPI_Request requests[], int *indices, MPI_Sta int index = 0; MPI_Status stat; MPI_Status *pstat = status == MPI_STATUSES_IGNORE ? MPI_STATUS_IGNORE : &stat; - index = waitany(incount, (MPI_Request*)requests, pstat); + index = waitany(incount, requests, pstat); if(index==MPI_UNDEFINED) return MPI_UNDEFINED; if(status != MPI_STATUSES_IGNORE) { status[count] = *pstat; @@ -1108,22 +1114,22 @@ int Request::waitsome(int incount, MPI_Request requests[], int *indices, MPI_Sta return count; } -MPI_Request Request::f2c(int id) { - char key[KEY_SIZE]; +MPI_Request Request::f2c(int id) +{ if(id==MPI_FORTRAN_REQUEST_NULL) - return static_cast(MPI_REQUEST_NULL); - return static_cast(F2C::f2c_lookup()->at(get_key(key,id))); + return MPI_REQUEST_NULL; + return static_cast(F2C::lookup()->at(id)); } void Request::free_f(int id) { if (id != MPI_FORTRAN_REQUEST_NULL) { - char key[KEY_SIZE]; - F2C::f2c_lookup()->erase(get_key(key, id)); + F2C::lookup()->erase(id); } } -int Request::get_status(MPI_Request req, int* flag, MPI_Status * status){ +int Request::get_status(const Request* req, int* flag, MPI_Status* status) +{ *flag=0; if(req != MPI_REQUEST_NULL && req->action_ != nullptr) { @@ -1150,13 +1156,14 @@ int Request::get_status(MPI_Request req, int* flag, MPI_Status * status){ return MPI_SUCCESS; } -int Request::grequest_start( MPI_Grequest_query_function *query_fn, MPI_Grequest_free_function *free_fn, MPI_Grequest_cancel_function *cancel_fn, void *extra_state, MPI_Request *request){ - +int Request::grequest_start(MPI_Grequest_query_function* query_fn, MPI_Grequest_free_function* free_fn, + MPI_Grequest_cancel_function* cancel_fn, void* extra_state, MPI_Request* request) +{ *request = new Request(); (*request)->flags_ |= MPI_REQ_GENERALIZED; (*request)->flags_ |= MPI_REQ_PERSISTENT; (*request)->refcount_ = 1; - ((*request)->generalized_funcs) = new s_smpi_mpi_generalized_request_funcs_t; + ((*request)->generalized_funcs) = std::make_unique(); ((*request)->generalized_funcs)->query_fn=query_fn; ((*request)->generalized_funcs)->free_fn=free_fn; ((*request)->generalized_funcs)->cancel_fn=cancel_fn; @@ -1166,8 +1173,9 @@ int Request::grequest_start( MPI_Grequest_query_function *query_fn, MPI_Grequest return MPI_SUCCESS; } -int Request::grequest_complete( MPI_Request request){ - if ((!(request->flags_ & MPI_REQ_GENERALIZED)) || request->generalized_funcs->mutex==NULL) +int Request::grequest_complete(MPI_Request request) +{ + if ((!(request->flags_ & MPI_REQ_GENERALIZED)) || request->generalized_funcs->mutex == nullptr) return MPI_ERR_REQUEST; request->generalized_funcs->mutex->lock(); request->flags_ |= MPI_REQ_COMPLETE; // in case wait would be called after complete @@ -1186,13 +1194,14 @@ void Request::set_nbc_requests(MPI_Request* reqs, int size){ } } -int Request::get_nbc_requests_size(){ +int Request::get_nbc_requests_size() const +{ return nbc_requests_size_; } -MPI_Request* Request::get_nbc_requests(){ +MPI_Request* Request::get_nbc_requests() const +{ return nbc_requests_; } - } }