X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/1ba3b199ce47dca5644315bf6009a795d3816ffd..1b3ef52aafb46cf06757353f5a85f3aa2f5c38a2:/src/smpi/mpi/smpi_request.cpp

diff --git a/src/smpi/mpi/smpi_request.cpp b/src/smpi/mpi/smpi_request.cpp
index 6711a16797..77885e4bc6 100644
--- a/src/smpi/mpi/smpi_request.cpp
+++ b/src/smpi/mpi/smpi_request.cpp
@@ -1,4 +1,4 @@
-/* Copyright (c) 2007-2021. The SimGrid Team. All rights reserved.          */
+/* Copyright (c) 2007-2022. 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. */
@@ -8,14 +8,16 @@
 #include "mc/mc.h"
 #include "private.hpp"
 #include "simgrid/Exception.hpp"
+#include "simgrid/s4u/ConditionVariable.hpp"
 #include "simgrid/s4u/Exec.hpp"
 #include "simgrid/s4u/Mutex.hpp"
-#include "simgrid/s4u/ConditionVariable.hpp"
 #include "smpi_comm.hpp"
 #include "smpi_datatype.hpp"
 #include "smpi_host.hpp"
 #include "smpi_op.hpp"
 #include "src/kernel/activity/CommImpl.hpp"
+#include "src/kernel/actor/ActorImpl.hpp"
+#include "src/kernel/actor/SimcallObserver.hpp"
 #include "src/mc/mc_replay.hpp"
 #include "src/smpi/include/smpi_actor.hpp"
 
@@ -31,7 +33,7 @@ static simgrid::config::Flag<double> smpi_test_sleep(
 
 std::vector<s_smpi_factor_t> smpi_ois_values;
 
-extern void (*smpi_comm_copy_data_callback)(simgrid::kernel::activity::CommImpl*, void*, size_t);
+extern std::function<void(simgrid::kernel::activity::CommImpl*, void*, size_t)> smpi_comm_copy_data_callback;
 
 namespace simgrid{
 namespace smpi{
@@ -69,6 +71,7 @@ Request::Request(const void* buf, int count, MPI_Datatype datatype, aid_t src, a
     refcount_ = 1;
   else
     refcount_ = 0;
+  message_id_ = 0;
   init_buffer(count);
   this->add_f();
 }
@@ -142,13 +145,10 @@ bool Request::match_common(MPI_Request req, MPI_Request sender, MPI_Request rece
     }
     if (receiver->tag_ == MPI_ANY_TAG)
       receiver->real_tag_ = sender->tag_;
-    if ((receiver->flags_ & MPI_REQ_PROBE) == 0 ){
-      if (receiver->real_size_ < sender->real_size_){
-        XBT_DEBUG("Truncating message - should not happen: receiver size : %zu < sender size : %zu", receiver->real_size_, sender->real_size_);
-        receiver->truncated_ = true;
-      } else if (receiver->real_size_ > sender->real_size_){
-        receiver->real_size_=sender->real_size_;
-      }
+    if ((receiver->flags_ & MPI_REQ_PROBE) == 0 && receiver->real_size_ < sender->real_size_) {
+      XBT_DEBUG("Truncating message - should not happen: receiver size : %zu < sender size : %zu", receiver->real_size_,
+                sender->real_size_);
+      receiver->truncated_ = true;
     }
     //0-sized datatypes/counts should not interfere and match
     if ( sender->real_size_ != 0 && receiver->real_size_ != 0 &&
@@ -186,7 +186,35 @@ bool Request::match_recv(void* a, void* b, simgrid::kernel::activity::CommImpl*)
 {
   auto ref = static_cast<MPI_Request>(a);
   auto req = static_cast<MPI_Request>(b);
-  return match_common(req, req, ref);
+  bool match = match_common(req, req, ref);
+  if (not match || ref->comm_ == MPI_COMM_UNINITIALIZED || ref->comm_->is_smp_comm())
+    return match;
+
+  if (ref->comm_->get_received_messages_count(ref->comm_->group()->rank(req->src_),
+                                              ref->comm_->group()->rank(req->dst_), req->tag_) == req->message_id_) {
+    if (((ref->flags_ & MPI_REQ_PROBE) == 0) && ((req->flags_ & MPI_REQ_PROBE) == 0)) {
+      XBT_DEBUG("increasing count in comm %p, which was %u from pid %ld, to pid %ld with tag %d", ref->comm_,
+                ref->comm_->get_received_messages_count(ref->comm_->group()->rank(req->src_),
+                                                        ref->comm_->group()->rank(req->dst_), req->tag_),
+                req->src_, req->dst_, req->tag_);
+      ref->comm_->increment_received_messages_count(ref->comm_->group()->rank(req->src_),
+                                                    ref->comm_->group()->rank(req->dst_), req->tag_);
+      if (ref->real_size_ > req->real_size_) {
+        ref->real_size_ = req->real_size_;
+      }
+    }
+  } else {
+    match = false;
+    req->flags_ &= ~MPI_REQ_MATCHED;
+    ref->detached_sender_ = nullptr;
+    XBT_DEBUG("Refusing to match message, as its ID is not the one I expect. in comm %p, %u != %u, "
+              "from pid %ld to pid %ld, with tag %d",
+              ref->comm_,
+              ref->comm_->get_received_messages_count(ref->comm_->group()->rank(req->src_),
+                                                      ref->comm_->group()->rank(req->dst_), req->tag_),
+              req->message_id_, req->src_, req->dst_, req->tag_);
+  }
+  return match;
 }
 
 bool Request::match_send(void* a, void* b, simgrid::kernel::activity::CommImpl*)
@@ -444,6 +472,9 @@ void Request::start()
     if (smpi_cfg_async_small_thresh() != 0 || (flags_ & MPI_REQ_RMA) != 0)
       mut->lock();
 
+    bool is_probe = ((flags_ & MPI_REQ_PROBE) != 0);
+    flags_ |= MPI_REQ_PROBE;
+
     if (smpi_cfg_async_small_thresh() == 0 && (flags_ & MPI_REQ_RMA) == 0) {
       mailbox = process->mailbox();
     } else if (((flags_ & MPI_REQ_RMA) != 0) || static_cast<int>(size_) < smpi_cfg_async_small_thresh()) {
@@ -463,7 +494,7 @@ void Request::start()
           mailbox = process->mailbox_small();
         }
       } else {
-        XBT_DEBUG("yes there was something for us in the large mailbox");
+        XBT_DEBUG("yes there was something for us in the small mailbox");
       }
     } else {
       mailbox = process->mailbox_small();
@@ -477,10 +508,22 @@ void Request::start()
         XBT_DEBUG("yes there was something for us in the small mailbox");
       }
     }
+    if(!is_probe)
+      flags_ &= ~MPI_REQ_PROBE;
+    kernel::actor::CommIrecvSimcall observer{process->get_actor()->get_impl(),
+                                             mailbox->get_impl(),
+                                             static_cast<unsigned char*>(buf_),
+                                             &real_size_,
+                                             &match_recv,
+                                             process->replaying() ? &smpi_comm_null_copy_buffer_callback
+                                                                  : smpi_comm_copy_data_callback,
+                                             this,
+                                             -1.0};
+    observer.set_tag(tag_);
+
+    action_ = kernel::actor::simcall_answered([&observer] { return kernel::activity::CommImpl::irecv(&observer); },
+                                              &observer);
 
-    action_   = simcall_comm_irecv(
-        process->get_actor()->get_impl(), mailbox->get_impl(), buf_, &real_size_, &match_recv,
-        process->replaying() ? &smpi_comm_null_copy_buffer_callback : smpi_comm_copy_data_callback, this, -1.0);
     XBT_DEBUG("recv simcall posted");
 
     if (smpi_cfg_async_small_thresh() != 0 || (flags_ & MPI_REQ_RMA) != 0)
@@ -492,6 +535,9 @@ void Request::start()
       TRACE_smpi_send(src_, src_, dst_, tag_, size_);
     this->print_request("New send");
 
+    message_id_=comm_->get_sent_messages_count(comm_->group()->rank(src_), comm_->group()->rank(dst_), tag_);
+    comm_->increment_sent_messages_count(comm_->group()->rank(src_), comm_->group()->rank(dst_), tag_);
+
     void* buf = buf_;
     if ((flags_ & MPI_REQ_SSEND) == 0 &&
         ((flags_ & MPI_REQ_RMA) != 0 || (flags_ & MPI_REQ_BSEND) != 0 ||
@@ -541,6 +587,9 @@ void Request::start()
     if (not(smpi_cfg_async_small_thresh() != 0 || (flags_ & MPI_REQ_RMA) != 0)) {
       mailbox = process->mailbox();
     } else if (((flags_ & MPI_REQ_RMA) != 0) || static_cast<int>(size_) < smpi_cfg_async_small_thresh()) { // eager mode
+      bool is_probe = ((flags_ & MPI_REQ_PROBE) != 0);
+      flags_ |= MPI_REQ_PROBE;
+
       mailbox = process->mailbox();
       XBT_DEBUG("Is there a corresponding recv already posted in the large mailbox %s?", mailbox->get_cname());
       simgrid::kernel::activity::ActivityImplPtr action = mailbox->iprobe(1, &match_send, static_cast<void*>(this));
@@ -562,19 +611,24 @@ void Request::start()
       } else {
         XBT_DEBUG("Yes there was something for us in the large mailbox");
       }
+      if(!is_probe)
+        flags_ &= ~MPI_REQ_PROBE;
     } else {
       mailbox = process->mailbox();
       XBT_DEBUG("Send request %p is in the large mailbox %s (buf: %p)", this, mailbox->get_cname(), buf_);
     }
 
     size_t payload_size_ = size_ + 16;//MPI enveloppe size (tag+dest+communicator)
-    action_              = simcall_comm_isend(
-        simgrid::kernel::actor::ActorImpl::by_pid(src_), mailbox->get_impl(), payload_size_, -1.0, buf, real_size_,
-        &match_send,
+    kernel::actor::CommIsendSimcall observer{
+        simgrid::kernel::actor::ActorImpl::by_pid(src_), mailbox->get_impl(), static_cast<double>(payload_size_), -1,
+        static_cast<unsigned char*>(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
-        detached_);
+        detached_};
+    observer.set_tag(tag_);
+    action_ = kernel::actor::simcall_answered([&observer] { return kernel::activity::CommImpl::isend(&observer); },
+                                              &observer);
     XBT_DEBUG("send simcall posted");
 
     /* FIXME: detached sends are not traceable (action_ == nullptr) */
@@ -630,7 +684,10 @@ int Request::test(MPI_Request * request, MPI_Status * status, int* flag) {
   if (((*request)->flags_ & (MPI_REQ_PREPARED | MPI_REQ_FINISHED)) == 0) {
     if ((*request)->action_ != nullptr && ((*request)->flags_ & MPI_REQ_CANCELLED) == 0){
       try{
-        *flag = simcall_comm_test((*request)->action_.get());
+        kernel::actor::ActorImpl* issuer = kernel::actor::ActorImpl::self();
+        kernel::actor::ActivityTestSimcall observer{issuer, (*request)->action_.get()};
+        *flag = kernel::actor::simcall_answered(
+            [&observer] { return observer.get_activity()->test(observer.get_issuer()); }, &observer);
       } catch (const Exception&) {
         *flag = 0;
         return ret;
@@ -696,7 +753,7 @@ int Request::testsome(int incount, MPI_Request requests[], int *count, int *indi
 
 int Request::testany(int count, MPI_Request requests[], int *index, int* flag, MPI_Status * status)
 {
-  std::vector<simgrid::kernel::activity::CommImpl*> comms;
+  std::vector<simgrid::kernel::activity::ActivityImpl*> comms;
   comms.reserve(count);
 
   *flag = 0;
@@ -706,7 +763,7 @@ int Request::testany(int count, MPI_Request requests[], int *index, int* flag, M
   std::vector<int> map; /** Maps all matching comms back to their location in requests **/
   for (int i = 0; i < count; i++) {
     if ((requests[i] != MPI_REQUEST_NULL) && requests[i]->action_ && not(requests[i]->flags_ & MPI_REQ_PREPARED)) {
-      comms.push_back(static_cast<simgrid::kernel::activity::CommImpl*>(requests[i]->action_.get()));
+      comms.push_back(requests[i]->action_.get());
       map.push_back(i);
     }
   }
@@ -717,7 +774,13 @@ int Request::testany(int count, MPI_Request requests[], int *index, int* flag, M
       simgrid::s4u::this_actor::sleep_for(nsleeps * smpi_test_sleep);
     ssize_t i;
     try{
-      i = simcall_comm_testany(comms.data(), comms.size()); // The i-th element in comms matches!
+      kernel::actor::ActorImpl* issuer = kernel::actor::ActorImpl::self();
+      kernel::actor::ActivityTestanySimcall observer{issuer, comms};
+      i = kernel::actor::simcall_answered(
+          [&observer] {
+            return kernel::activity::ActivityImpl::test_any(observer.get_issuer(), observer.get_activities());
+          },
+          &observer);
     } catch (const Exception&) {
       XBT_DEBUG("Exception in testany");
       return 0;
@@ -1027,7 +1090,11 @@ 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_.get(), -1.0);
+        kernel::actor::ActorImpl* issuer = kernel::actor::ActorImpl::self();
+        kernel::actor::ActivityWaitSimcall observer{issuer, (*request)->action_.get(), -1};
+        kernel::actor::simcall_blocking(
+            [&observer] { observer.get_activity()->wait_for(observer.get_issuer(), observer.get_timeout()); },
+            &observer);
       } catch (const CancelException&) {
         XBT_VERB("Request cancelled");
       }
@@ -1068,7 +1135,7 @@ int Request::waitany(int count, MPI_Request requests[], MPI_Status * status)
 
   if(count > 0) {
     // Wait for a request to complete
-    std::vector<simgrid::kernel::activity::CommImpl*> comms;
+    std::vector<simgrid::kernel::activity::ActivityImpl*> comms;
     std::vector<int> map;
     XBT_DEBUG("Wait for one of %d", count);
     for(int i = 0; i < count; i++) {
@@ -1076,7 +1143,7 @@ int Request::waitany(int count, MPI_Request requests[], MPI_Status * status)
           not(requests[i]->flags_ & MPI_REQ_FINISHED)) {
         if (requests[i]->action_ != nullptr) {
           XBT_DEBUG("Waiting any %p ", requests[i]);
-          comms.push_back(static_cast<simgrid::kernel::activity::CommImpl*>(requests[i]->action_.get()));
+          comms.push_back(requests[i]->action_.get());
           map.push_back(i);
         } else {
           // This is a finished detached request, let's return this one
@@ -1095,7 +1162,14 @@ int Request::waitany(int count, MPI_Request requests[], MPI_Status * status)
       XBT_DEBUG("Enter waitany for %zu comms", comms.size());
       ssize_t i;
       try{
-        i = simcall_comm_waitany(comms.data(), comms.size(), -1);
+        kernel::actor::ActorImpl* issuer = kernel::actor::ActorImpl::self();
+        kernel::actor::ActivityWaitanySimcall observer{issuer, comms, -1};
+        i = kernel::actor::simcall_blocking(
+            [&observer] {
+              kernel::activity::ActivityImpl::wait_any_for(observer.get_issuer(), observer.get_activities(),
+                                                           observer.get_timeout());
+            },
+            &observer);
       } catch (const CancelException&) {
         XBT_INFO("request cancelled");
         i = -1;