Merge branch 'master' of https://framagit.org/simgrid/simgrid

[simgrid.git] / src / s4u / s4u_Comm.cpp

diff --git a/src/s4u/s4u_Comm.cpp b/src/s4u/s4u_Comm.cpp
index 408d1a3..fe13409 100644 (file)
--- a/src/s4u/s4u_Comm.cpp
+++ b/src/s4u/s4u_Comm.cpp
@@ -29,7 +29,7 @@ CommPtr Comm::set_copy_data_callback(const std::function<void(kernel::activity::
 }
 
 void Comm::copy_buffer_callback(kernel::activity::CommImpl* comm, void* buff,
-                                size_t buff_size) // XBT_ATTRIB_DEPRECATED_v337
+                                size_t buff_size) // XBT_ATTRIB_DEPRECATED_v338
 {
   XBT_DEBUG("Copy the data over");
   memcpy(comm->dst_buff_, buff, buff_size);
@@ -41,7 +41,7 @@ void Comm::copy_buffer_callback(kernel::activity::CommImpl* comm, void* buff,
 }
 
 void Comm::copy_pointer_callback(kernel::activity::CommImpl* comm, void* buff,
-                                 size_t buff_size) // XBT_ATTRIB_DEPRECATED_v337
+                                 size_t buff_size) // XBT_ATTRIB_DEPRECATED_v338
 {
   xbt_assert((buff_size == sizeof(void*)), "Cannot copy %zu bytes: must be sizeof(void*)", buff_size);
   *(void**)(comm->dst_buff_) = buff;
@@ -78,12 +78,13 @@ void Comm::send(kernel::actor::ActorImpl* sender, const Mailbox* mbox, double ta
     simgrid::kernel::activity::ActivityImplPtr comm = nullptr;
 
     simgrid::kernel::actor::CommIsendSimcall send_observer{
-        sender,  mbox->get_impl(), task_size, rate, static_cast<unsigned char*>(src_buff), src_buff_size, match_fun,
-        nullptr, copy_data_fun,    data,      false};
+        sender,        mbox->get_impl(), task_size, rate,          static_cast<unsigned char*>(src_buff),
+        src_buff_size, match_fun,        nullptr,   copy_data_fun, data,
+        false,         "Isend"};
     comm = simgrid::kernel::actor::simcall_answered(
         [&send_observer] { return simgrid::kernel::activity::CommImpl::isend(&send_observer); }, &send_observer);
 
-    if (simgrid::kernel::actor::ActivityWaitSimcall wait_observer{sender, comm.get(), timeout};
+    if (simgrid::kernel::actor::ActivityWaitSimcall wait_observer{sender, comm.get(), timeout, "Wait"};
         simgrid::kernel::actor::simcall_blocking(
             [&wait_observer] {
               wait_observer.get_activity()->wait_for(wait_observer.get_issuer(), wait_observer.get_timeout());
@@ -95,7 +96,7 @@ void Comm::send(kernel::actor::ActorImpl* sender, const Mailbox* mbox, double ta
   } else {
     simgrid::kernel::actor::CommIsendSimcall observer(sender, mbox->get_impl(), task_size, rate,
                                                       static_cast<unsigned char*>(src_buff), src_buff_size, match_fun,
-                                                      nullptr, copy_data_fun, data, false);
+                                                      nullptr, copy_data_fun, data, false, "Isend");
     simgrid::kernel::actor::simcall_blocking([&observer, timeout] {
       simgrid::kernel::activity::ActivityImplPtr comm = simgrid::kernel::activity::CommImpl::isend(&observer);
       comm->wait_for(observer.get_issuer(), timeout);
@@ -122,11 +123,12 @@ void Comm::recv(kernel::actor::ActorImpl* receiver, const Mailbox* mbox, void* d
                                                       match_fun,
                                                       copy_data_fun,
                                                       data,
-                                                      rate};
+                                                      rate,
+                                                      "Irecv"};
     comm = simgrid::kernel::actor::simcall_answered(
         [&observer] { return simgrid::kernel::activity::CommImpl::irecv(&observer); }, &observer);
 
-    if (simgrid::kernel::actor::ActivityWaitSimcall wait_observer{receiver, comm.get(), timeout};
+    if (simgrid::kernel::actor::ActivityWaitSimcall wait_observer{receiver, comm.get(), timeout, "wait"};
         simgrid::kernel::actor::simcall_blocking(
             [&wait_observer] {
               wait_observer.get_activity()->wait_for(wait_observer.get_issuer(), wait_observer.get_timeout());
@@ -137,7 +139,7 @@ void Comm::recv(kernel::actor::ActorImpl* receiver, const Mailbox* mbox, void* d
     comm = nullptr;
   } else {
     simgrid::kernel::actor::CommIrecvSimcall observer(receiver, mbox->get_impl(), static_cast<unsigned char*>(dst_buff),
-                                                      dst_buff_size, match_fun, copy_data_fun, data, rate);
+                                                      dst_buff_size, match_fun, copy_data_fun, data, rate, "Irecv");
     simgrid::kernel::actor::simcall_blocking([&observer, timeout] {
       simgrid::kernel::activity::ActivityImplPtr comm = simgrid::kernel::activity::CommImpl::irecv(&observer);
       comm->wait_for(observer.get_issuer(), timeout);
@@ -289,6 +291,14 @@ Actor* Comm::get_sender() const
   return sender ? sender->get_ciface() : nullptr;
 }
 
+Actor* Comm::get_receiver() const
+{
+  kernel::actor::ActorImplPtr receiver = nullptr;
+  if (pimpl_)
+    receiver = boost::static_pointer_cast<kernel::activity::CommImpl>(pimpl_)->dst_actor_;
+  return receiver ? receiver->get_ciface() : nullptr;
+}
+
 bool Comm::is_assigned() const
 {
   return (pimpl_ && boost::static_pointer_cast<kernel::activity::CommImpl>(pimpl_)->is_assigned()) ||
@@ -304,14 +314,15 @@ Comm* Comm::do_start()
     xbt_assert(src_buff_ == nullptr && dst_buff_ == nullptr,
                "Direct host-to-host communications cannot carry any data.");
     XBT_DEBUG("host-to-host Comm. Pimpl already created and set, just start it.");
-    on_send(*this);
-    on_recv(*this);
+    fire_on_start();
+    fire_on_this_start();
     kernel::actor::simcall_answered([this] {
       pimpl_->set_state(kernel::activity::State::READY);
       boost::static_pointer_cast<kernel::activity::CommImpl>(pimpl_)->start();
     });
   } else if (src_buff_ != nullptr) { // Sender side
     on_send(*this);
+    on_this_send(*this);
     kernel::actor::CommIsendSimcall observer{sender_,
                                              mailbox_->get_impl(),
                                              remains_,
@@ -322,12 +333,14 @@ Comm* Comm::do_start()
                                              clean_fun_,
                                              copy_data_function_,
                                              get_data<void>(),
-                                             detached_};
+                                             detached_,
+                                             "Isend"};
     pimpl_ = kernel::actor::simcall_answered([&observer] { return kernel::activity::CommImpl::isend(&observer); },
                                              &observer);
   } else if (dst_buff_ != nullptr) { // Receiver side
     xbt_assert(not detached_, "Receive cannot be detached");
     on_recv(*this);
+    on_this_recv(*this);
     kernel::actor::CommIrecvSimcall observer{receiver_,
                                              mailbox_->get_impl(),
                                              static_cast<unsigned char*>(dst_buff_),
@@ -335,7 +348,8 @@ Comm* Comm::do_start()
                                              match_fun_,
                                              copy_data_function_,
                                              get_data<void>(),
-                                             rate_};
+                                             rate_,
+                                             "Irecv"};
     pimpl_ = kernel::actor::simcall_answered([&observer] { return kernel::activity::CommImpl::irecv(&observer); },
                                              &observer);
   } else {
@@ -348,6 +362,11 @@ Comm* Comm::do_start()
   if (not detached_) {
     pimpl_->set_iface(this);
     pimpl_->set_actor(sender_);
+    // Only throw the signal when both sides are here and the status is READY
+    if (pimpl_->get_state() != kernel::activity::State::WAITING) {
+      fire_on_start();
+      fire_on_this_start();
+    }
   }
 
   state_ = State::STARTED;
@@ -393,11 +412,13 @@ Comm* Comm::wait_for(double timeout)
         return start()->wait_for(timeout); // In the case of host2host comm, do it in two simcalls
       } else if (src_buff_ != nullptr) {
         on_send(*this);
+        on_this_send(*this);
         send(sender_, mailbox_, remains_, rate_, src_buff_, src_buff_size_, match_fun_, copy_data_function_,
              get_data<void>(), timeout);
 
       } else { // Receiver
         on_recv(*this);
+        on_this_recv(*this);
         recv(receiver_, mailbox_, dst_buff_, &dst_buff_size_, match_fun_, copy_data_function_, get_data<void>(),
              timeout, rate_);
       }
@@ -405,7 +426,7 @@ Comm* Comm::wait_for(double timeout)
     case State::STARTED:
       try {
         issuer = kernel::actor::ActorImpl::self();
-        kernel::actor::ActivityWaitSimcall observer{issuer, pimpl_.get(), timeout};
+        kernel::actor::ActivityWaitSimcall observer{issuer, pimpl_.get(), timeout, "Wait"};
         if (kernel::actor::simcall_blocking(
                 [&observer] { observer.get_activity()->wait_for(observer.get_issuer(), observer.get_timeout()); },
                 &observer)) {
@@ -451,7 +472,7 @@ ssize_t Comm::wait_any_for(const std::vector<CommPtr>& comms, double timeout)
 void Comm::wait_all(const std::vector<CommPtr>& comms)
 {
   // TODO: this should be a simcall or something
-  for (auto& comm : comms)
+  for (const auto& comm : comms)
     comm->wait();
 }