Only wait on active requests (not null and not finished)

[simgrid.git] / src / smpi / mpi / smpi_request.cpp

diff --git a/src/smpi/mpi/smpi_request.cpp b/src/smpi/mpi/smpi_request.cpp
index 85a9497..9c2653a 100644 (file)
--- a/src/smpi/mpi/smpi_request.cpp
+++ b/src/smpi/mpi/smpi_request.cpp
@@ -115,11 +115,12 @@ int Request::match_recv(void* a, void* b, simgrid::kernel::activity::CommImpl*)
 {
   MPI_Request ref = static_cast<MPI_Request>(a);
   MPI_Request req = static_cast<MPI_Request>(b);
-  XBT_DEBUG("Trying to match a recv of src %d against %d, tag %d against %d",ref->src_,req->src_, ref->tag_, req->tag_);
+  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->src_ == MPI_ANY_SOURCE || req->src_ == ref->src_)
+  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)
@@ -141,11 +142,12 @@ int Request::match_send(void* a, void* b, simgrid::kernel::activity::CommImpl*)
 {
   MPI_Request ref = static_cast<MPI_Request>(a);
   MPI_Request req = static_cast<MPI_Request>(b);
-  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_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((req->src_ == MPI_ANY_SOURCE || req->src_ == ref->src_)
+  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_;
@@ -548,7 +550,7 @@ int Request::test(MPI_Request * request, MPI_Status * status, int* flag) {
     if ((*request)->action_ != nullptr){
       try{
         *flag = simcall_comm_test((*request)->action_);
-      } catch (const xbt_ex&) {
+      } catch (const Exception&) {
         *flag = 0;
         return ret;
       }
@@ -592,15 +594,15 @@ int Request::testsome(int incount, MPI_Request requests[], int *count, int *indi
 
   *count = 0;
   for (int i = 0; i < incount; i++) {
-    if (requests[i] != MPI_REQUEST_NULL) {
+    if (requests[i] != MPI_REQUEST_NULL && not (requests[i]->flags_ & MPI_REQ_FINISHED)) {
       ret = test(&requests[i], pstat, &flag);
       if(ret!=MPI_SUCCESS)
         error = 1;
       if(flag) {
-        indices[i] = 1;
-        (*count)++;
+        indices[*count] = i;
         if (status != MPI_STATUSES_IGNORE)
-          status[i] = *pstat;
+          status[*count] = *pstat;
+        (*count)++;
         if ((requests[i] != MPI_REQUEST_NULL) && (requests[i]->flags_ & MPI_REQ_NON_PERSISTENT))
           requests[i] = MPI_REQUEST_NULL;
       }
@@ -639,7 +641,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 (const xbt_ex&) {
+    } catch (const Exception&) {
+      XBT_DEBUG("Exception in testany");
       return 0;
     }
     
@@ -666,6 +669,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;
@@ -673,8 +677,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);
   }
 
@@ -800,8 +806,7 @@ void Request::finish_wait(MPI_Request* request, MPI_Status * status)
     return;
   }
 
-  if (not(req->detached_ && ((req->flags_ & MPI_REQ_SEND) != 0)) && ((req->flags_ & MPI_REQ_PREPARED) == 0) &&
-      ((req->flags_ & MPI_REQ_GENERALIZED) == 0)) {
+  if ((req->flags_ & (MPI_REQ_PREPARED | MPI_REQ_GENERALIZED | MPI_REQ_FINISHED)) == 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);
@@ -810,32 +815,34 @@ void Request::finish_wait(MPI_Request* request, MPI_Status * status)
       // this handles the case were size in receive differs from size in send
       status->count = req->real_size_;
     }
+    //detached send will be finished at the other end
+    if (not(req->detached_ && ((req->flags_ & MPI_REQ_SEND) != 0))) {
+      req->print_request("Finishing");
+      MPI_Datatype datatype = req->old_type_;
+
+      // 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_privatize_global_variables != SmpiPrivStrategies::NONE &&
+            static_cast<char*>(req->old_buf_) >= smpi_data_exe_start &&
+            static_cast<char*>(req->old_buf_) < smpi_data_exe_start + smpi_data_exe_size) {
+          XBT_VERB("Privatization : We are unserializing to a zone in global memory  Switch data segment ");
+          smpi_switch_data_segment(simgrid::s4u::Actor::self());
+        }
 
-    req->print_request("Finishing");
-    MPI_Datatype datatype = req->old_type_;
-
-// 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_privatize_global_variables != SmpiPrivStrategies::NONE &&
-          static_cast<char*>(req->old_buf_) >= smpi_data_exe_start &&
-          static_cast<char*>(req->old_buf_) < smpi_data_exe_start + smpi_data_exe_size) {
-        XBT_VERB("Privatization : We are unserializing to a zone in global memory  Switch data segment ");
-        smpi_switch_data_segment(simgrid::s4u::Actor::self());
-      }
-
-      if(datatype->flags() & DT_FLAG_DERIVED){
-        // This part handles the problem of non-contignous memory the unserialization at the reception
-        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_);
-      } 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);
+        if(datatype->flags() & DT_FLAG_DERIVED){
+          // This part handles the problem of non-contignous memory the unserialization at the reception
+          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_);
+        } 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_);
         }
-        xbt_free(req->buf_);
       }
     }
   }
@@ -901,7 +908,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 (const xbt_ex&) {
+      } catch (const Exception&) {
         XBT_VERB("Request cancelled");
       }
   }
@@ -964,7 +971,7 @@ 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 (const xbt_ex&) {
+      } catch (const Exception&) {
         XBT_INFO("request %d cancelled ", i);
         return i;
       }
@@ -1053,7 +1060,6 @@ 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);
   if(index==MPI_UNDEFINED) return MPI_UNDEFINED;
   if(status != MPI_STATUSES_IGNORE) {
@@ -1062,7 +1068,8 @@ 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 (i!=index && requests[i] != MPI_REQUEST_NULL 
+        && not(requests[i]->flags_ & MPI_REQ_FINISHED)) {
       test(&requests[i], pstat,&flag);
       if (flag==1){
         indices[count] = i;